@evenicanpm/storefront-core 1.0.0-alpha → 1.0.1

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

@@ -12,7 +12,8 @@ import {
 import * as translator from "./e4.translator";
 import getGraphqlClient from "../../lib/get-graphql-client";
 import { ProductApi } from "../../types/Datasource";
-import { generateCategoryFilterString } from "./e4.translator";
+// See TODO below
+//import { generateCategoryFilterString } from "./e4.translator";
 
 const product: ProductApi = {
   async getProductById(
@@ -61,7 +62,9 @@ const product: ProductApi = {
     const { data, errors } = await e4Api.productTypeaheadSearchByCategory({
       input: {
         search: input.searchText,
-        categoryId: await generateCategoryFilterString(input.category ?? 0),
+        // TODO: investigate why this was added..
+        // it's throwing a type error.
+        //categoryId: await generateCategoryFilterString(input.category ?? 0),
         top: 10,
         skip: 0,
       },
@@ -152,6 +155,23 @@ const product: ProductApi = {
   ): Promise<ProductSearchResult[]> {
     throw new Error(`Function not implemented.${input}`);
   },
+  async getProductPrices(
+    input: productSchema.ProductPriceInput,
+  ): Promise<productSchema.ProductPrice[]> {
+    const e4Api = await getGraphqlClient();
+    const { data, errors } = await e4Api.GetProductsByIds({
+      ids: input.productIds?.map(String),
+    });
+
+    if (errors) {
+      throw new Error("Error getting products");
+    }
+
+    const translatedData = translator.productPricesTransformValidate(
+      data?.getProductsByIds as Product[],
+    );
+    return translatedData;
+  },
 };
 
 export default product;

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

@@ -3,7 +3,7 @@ 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 user from "./user/e4-user.datasource";
 import session from "./e4-session.datasource";
 import { cart } from "./e4-cart.datasource";
 import order from "./e4-order.datasource";

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

@@ -63,6 +63,30 @@ export const productMap = {
   },
 };
 
+export const productPricesMap = {
+  id: [
+    {
+      key: "ProductId",
+      transform: (id: string) => {
+        if (id !== null) return parseInt(id);
+      },
+    },
+    {
+      key: "ListingId",
+      transform: (id: string) => {
+        if (id !== null) return parseInt(id);
+      },
+    },
+  ],
+  price: [
+    { key: "Price", default: 0 },
+    { key: "BasePrice", default: 0 },
+    { key: "AdjustedPrice", default: 0 },
+    { key: "CustomerContextualPrice", default: 0 },
+  ],
+  sku: "ItemId",
+};
+
 export const productDetailsMap = {
   ...productMap,
   MasterProductId: "MasterProductId",

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

@@ -4,6 +4,7 @@ import {
   productSchema,
   ProductDetails,
   SearchByCriteriaInput,
+  ProductPrice,
 } from "@/api-manager/schemas/product.schema";
 import { Address } from "@/api-manager/schemas/address.schema";
 import { User } from "@/api-manager/schemas/user.schema";
@@ -31,12 +32,14 @@ import {
   cartMap,
   productDetailsMap,
   productMap,
+  productPricesMap,
   addressReverseMap,
   countriesMap,
   countryMap,
   deliveryOptionsMap,
 } from "./e4.remaps";
 import { CategoryHierarchy } from "@/lib/category-helpers";
+import { productPriceSchema } from "@/api-manager/schemas/d365.schema";
 
 interface TransformedRefinerValue {
   RefinerRecordId: number;
@@ -338,6 +341,20 @@ export const productTransformValidate = (
   return translatedData;
 };
 
+export const productPricesTransformValidate = (
+  products: Product[],
+): ProductPrice[] => {
+  const translatedData = products.map(
+    (p) => merge(p, productPricesMap) as ProductPrice,
+  );
+  try {
+    translatedData.map((pp: ProductPrice) => productPriceSchema.parse(pp));
+  } catch (e) {
+    console.warn("ProductPrice data does not match retail-proxy schema", e);
+  }
+  return translatedData;
+};
+
 export const productWithCategoryTransformValidate = (
   productData: Product,
 ): ProductSearchResult => {
@@ -475,7 +492,8 @@ const getStateId = async (stateCode: string, countryId: string) => {
   } else {
     const e4Api = await getGraphqlClient();
     const { data } = await e4Api.e4Country({ id: countryId });
-    countryCache.set(cacheKey, data?.country as Country);
+    country = data?.country as Country;
+    countryCache.set(cacheKey, country);
   }
 
   const state = country?.state?.find((s) => s?.code === stateCode);

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

@@ -1,11 +1,20 @@
-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 getGraphqlClient from "../../../lib/get-graphql-client";
+import {
+  CopyCartToWishlistInput,
+  User,
+  UserCounts,
+  Wishlist,
+  WishlistCreateInput,
+  WishlistDetailInput,
+  WishlistLinesInput,
+} from "@/api-manager/schemas/user.schema";
+import * as translator from "../e4.translator";
+import { userMap } from "../e4.remaps";
 import { merge } from "object-mapper";
+import { UserApi } from "@/api-manager/types/Datasource";
+import { translateWishList } from "./e4-user.translator";
 
-const user = {
+const user: UserApi = {
   async updateUser(user: User): Promise<User> {
     const e4Api = await getGraphqlClient(true);
 
@@ -46,22 +55,21 @@ const user = {
       addressCount: data?.getAddressCount ?? 0,
     };
   },
-  async getWishlists(): Promise<WishList[]> {
+  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 ?? [];
+    return translateWishList(data);
   },
 
-  async getWishlistDetails(id: string): Promise<WishList> {
+  async getWishlistDetails(input: WishlistDetailInput): Promise<Wishlist> {
     const e4Api = await getGraphqlClient(true);
 
-    const { data, errors } = await e4Api.e4WishListReadMD({ id });
+    const { data, errors } = await e4Api.e4WishListReadMD({ id: input.Id });
 
     if (errors) {
       throw new Error("Error getting wishlist details");
@@ -79,16 +87,17 @@ const user = {
         edges: [],
         ...wishList.products,
       },
-    } as unknown as WishList;
+    } as unknown as Wishlist;
   },
-  async createWishlist(wishlist: CreateWishListInput): Promise<WishList> {
-    if (!wishlist.name) {
+  async createWishlist(input: WishlistCreateInput): Promise<Wishlist> {
+    const { Name: name } = input;
+    if (name) {
       throw new Error("Wishlist name is required");
     }
 
     const e4Api = await getGraphqlClient(true);
 
-    const { data, errors } = await e4Api.upsertWishlist({ wishlist });
+    const { data, errors } = await e4Api.upsertWishlist({ wishlist: { name } });
 
     if (errors) {
       throw new Error("Error creating wishlist");
@@ -100,18 +109,31 @@ const user = {
       throw new Error("No wishlist found");
     }
 
-    return wishList as WishList;
+    return wishList as Wishlist;
   },
-  async deleteWishlist(id: string): Promise<string> {
+  async deleteWishlist(input: WishlistDetailInput): Promise<void> {
     const e4Api = await getGraphqlClient(true);
 
-    const { data, errors } = await e4Api.deleteWishList({ id });
+    const { data, errors } = await e4Api.deleteWishList({ id: input.Id });
 
     if (errors) {
       throw new Error("Error creating wishlist");
     }
+  },
+  async updateWishlist(input: WishlistLinesInput): Promise<Wishlist> {
+    throw new Error("updateWishlist not implemented");
+  },
+
+  async addProductsToWishlist(input: WishlistLinesInput): Promise<Wishlist> {
+    throw new Error("addProductsToWishlist not implemented");
+  },
+
+  async removeProductsFromWishlist(input: WishlistLinesInput): Promise<void> {
+    throw new Error("removeProductsFromWishlist not implemented");
+  },
 
-    return data?.deleteWishList ?? "";
+  async copyCartToWishlist(input: CopyCartToWishlistInput): Promise<Wishlist> {
+    throw new Error("copyCartToWishlist not implemented");
   },
 };
 

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

@@ -0,0 +1,4 @@
+export const wishListMap = {
+  "[].id": "[].Id",
+  "[].name": "[].Name",
+};

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

@@ -0,0 +1,10 @@
+import { E4WishListListSmQuery } from "../graphqlRequestSdk";
+import { merge } from "object-mapper";
+import { wishListMap } from "./e4-user.remaps";
+import { Wishlist } from "@/api-manager/schemas/user.schema";
+
+export const translateWishList = (data: E4WishListListSmQuery) => {
+  const e4WishList = data.wishlistList.nodes;
+  const translatedData = merge(e4WishList, wishListMap) as Wishlist[];
+  return translatedData;
+};

package/src/api-manager/index.ts

@@ -4,6 +4,7 @@ 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 {
@@ -18,9 +19,25 @@ const Config = z.object({
   overrides: z.record(z.string(), z.string()),
 });
 
+const OVERRIDES_FILE = "./overrides.datasource.ts";
+const CORE_DATASOURCES = [
+  "user",
+  "session",
+  "cart",
+  "product",
+  "categories",
+  "order",
+  "address",
+  "organization",
+];
 /**
  * Loads up all specified apis/datasources based on parsed config
- * and returns the ApiManager object.
+ * and returns the ApiManager object. Also handles "project" overrides
+ * by checking inside a specific folder for API's. Will grab default export
+ * from specified folder, validate the API schema and then prioritize returning
+ * that from api-manager.
+ *
+ * In this way, we have two levels of configuration of the api-manager.
  * @returns ApiManager object.
  */
 async function createApiManager() {
@@ -32,6 +49,26 @@ async function createApiManager() {
     }
   }
 
+  const storefrontOverrides: { [key: string]: any } = {};
+
+  // @ts-ignore
+  function importAll(r) {
+    r.keys().forEach(
+      (key: keyof typeof storefrontOverrides) =>
+        (storefrontOverrides[key] = r(key)),
+    );
+  }
+
+  // Arguments must be literals not variables.
+  importAll(
+    // @ts-ignore
+    require.context(
+      "@storefront/extensions/api-manager-overrides",
+      true,
+      /overrides\.datasource\.ts/,
+    ),
+  );
+
   const context = await getContextFromCookie();
   const datasourceMap: Record<string, Datasource> = {
     d365: new D365Datasource("d365", context),
@@ -46,26 +83,51 @@ async function createApiManager() {
   );
 
   const getDatasource = (entityName: EntityNames) => {
+    // Project-Level Overrides
+    let projectOverrides = {};
+    if (storefrontOverrides?.[OVERRIDES_FILE]?.["default"]?.[entityName]) {
+      projectOverrides =
+        storefrontOverrides[OVERRIDES_FILE]["default"][entityName];
+    }
+
+    // Config-Level Overrides
     const override = config?.overrides?.[entityName];
+
+    // Build the base entity from api-manager config settings
+    let baseEntity = {};
     if (override) {
-      return (
+      baseEntity =
         secondaryDatasources.find((ds) => ds.name === override) ??
-        primaryDatasource
-      );
+        primaryDatasource;
+    } else {
+      baseEntity = primaryDatasource;
+    }
+
+    // Attach Project Overrides to Entity
+    for (const key in projectOverrides) {
+      baseEntity[entityName][key] = projectOverrides[key];
     }
-    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,
+    return baseEntity;
   };
+
+  const datasources = {};
+
+  CORE_DATASOURCES.forEach((entityName) => {
+    const datasource = getDatasource(entityName as EntityNames);
+    datasources[entityName] = datasource[entityName];
+  });
+
+  storefrontOverrides[OVERRIDES_FILE]?.default &&
+    Object.keys(storefrontOverrides[OVERRIDES_FILE]["default"]).forEach(
+      (key) => {
+        if (!CORE_DATASOURCES.includes(key)) {
+          datasources[key] =
+            storefrontOverrides[OVERRIDES_FILE]["default"][key];
+        }
+      },
+    );
+  return datasources;
 }
 
 export default createApiManager;

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

@@ -6,9 +6,6 @@ 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
@@ -41,10 +38,13 @@ const getGraphQLClient = async (withAuth = false) => {
 
   // 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",
-  });
+  const client = new GraphQLClient(
+    process.env.NEXT_PUBLIC_E4_API_ENDPOINT || "",
+    {
+      headers,
+      credentials: "include",
+    },
+  );
 
   client.setHeaders(headers);
   return getSdk(client);

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

@@ -9,25 +9,6 @@ export const addressTypeSchema = z
   })
   .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(),
 });
@@ -40,6 +21,7 @@ const getDeliveryOptionsInput = z.object({
   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>;

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

@@ -4,6 +4,7 @@ import {
   cartLineSchema,
   cartSchema,
   retrievePaymentResultSettingsSchema,
+  searchAreaSchema,
   simpleProductSchema,
   tokenizedPaymentCardSchema,
 } from "./d365.schema";
@@ -67,6 +68,20 @@ export const removeCartLineDeliveryModeInput = z.object({
   cart: extendedCartSchema.partial(),
 });
 
+const SimpleCartLinesSearchCriteria = z.object({
+  productId: z.number(),
+  deliveryMode: z.string().optional(),
+  inventLocationId: z.string().optional(),
+});
+
+const InventorySearchCartLinesCriteriaInput = z.object({
+  searchCriteria: z.object({
+    cartLines: SimpleCartLinesSearchCriteria.array(),
+    searchArea: searchAreaSchema.optional(),
+  }),
+  allDimensionsSelected: z.boolean(),
+});
+
 // Typescript Types
 // export type Cart = z.infer<typeof cartSchema>;
 // export type CartLine = z.infer<typeof cartLineSchema>;
@@ -90,3 +105,6 @@ export type RemoveCartLineDeliveryModeInput = z.infer<
   typeof removeCartLineDeliveryModeInput
 >;
 export type CheckoutInput = z.infer<typeof checkoutInput>;
+export type InventorySearchCartLinesCriteriaInput = z.infer<
+  typeof InventorySearchCartLinesCriteriaInput
+>;

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

@@ -6,6 +6,7 @@ import {
   productSearchResultSchema,
   queryResultSettingsSchema,
   searchAreaSchema,
+  productPriceSchema,
 } from "./d365.schema";
 import {
   AttributeValue,
@@ -58,7 +59,7 @@ export const productWCategorySchema = productSchema.extend({
 });
 
 export const getProductByIdInput = z.object({
-  id: z.number().or(z.string()),
+  id: z.number().or(z.string()).or(z.undefined()),
 });
 
 export const getRelatedProductsInput = z.object({
@@ -117,6 +118,10 @@ const InventorySearchCriteriaInput = z.object({
   allDimensionsSelected: z.boolean(),
 });
 
+const productPriceInput = z.object({
+  productIds: z.number().array(),
+});
+
 // entities
 export type Product = z.infer<typeof productSchema>;
 export type ProductDetails = SimpleProduct & {
@@ -138,3 +143,5 @@ export type SearchByCriteriaResponse = z.infer<typeof searchByCriteriaResponse>;
 export type InventorySearchCriteriaInput = z.infer<
   typeof InventorySearchCriteriaInput
 >;
+export type ProductPrice = z.infer<typeof productPriceSchema>;
+export type ProductPriceInput = z.infer<typeof productPriceInput>;

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

@@ -1,5 +1,10 @@
 import z from "zod";
-import { customerSchema } from "./d365.schema";
+import {
+  customerSchema,
+  productListLineSchema,
+  productListSchema,
+  simpleProductSchema,
+} from "./d365.schema";
 
 export const userCountsSchema = z.object({
   orderCount: z.number().optional(),
@@ -12,3 +17,49 @@ export const extendedCustomerSchema = customerSchema.extend({
 
 export type User = z.infer<typeof extendedCustomerSchema>;
 export type UserCounts = z.infer<typeof userCountsSchema>;
+
+// Wishlist
+
+export const extendedProductListLineSchema = productListLineSchema.extend({
+  Product: simpleProductSchema.optional(),
+});
+
+export const extendedWishlistSchema = productListSchema
+  .omit({ ProductListLines: true })
+  .extend({ ProductListLines: extendedProductListLineSchema.array() });
+
+const wishlistBaseInput = z.object({
+  Id: z.string(),
+});
+
+export const wishlistCreateInput = wishlistBaseInput.extend({
+  Name: z.string(),
+  Comment: z.string().optional(),
+  IsPublic: z.boolean().optional(),
+});
+
+const updateWishlistInput = wishlistBaseInput.extend({
+  Name: z.string(),
+});
+
+const wishlistLinesInput = wishlistBaseInput.extend({
+  ProductListLines: productListLineSchema.array(),
+});
+
+const copyCartToWishlistInput = z.object({
+  Id: z.string(),
+  CartID: z.string(),
+  IsRewrite: z.boolean(),
+  IsQuantityAggregate: z.boolean(),
+});
+
+export type Wishlist = z.infer<typeof productListSchema>;
+export type ExtendedWishlist = z.infer<typeof extendedWishlistSchema>;
+export type ExtendedProductListLine = z.infer<
+  typeof extendedProductListLineSchema
+>;
+export type WishlistDetailInput = z.infer<typeof wishlistBaseInput>;
+export type WishlistCreateInput = z.infer<typeof wishlistCreateInput>;
+export type UpdateWishlistInput = z.infer<typeof updateWishlistInput>;
+export type WishlistLinesInput = z.infer<typeof wishlistLinesInput>;
+export type CopyCartToWishlistInput = z.infer<typeof copyCartToWishlistInput>;

package/src/api-manager/services/address/queries/get-states.ts

@@ -5,7 +5,7 @@ import { createQuery, createApiPath } from "../../create-query";
 const apiPath = createApiPath("address", "getStates");
 const config = {
   queryKey: "states",
-  disablePropertis: ["countryId"],
+  disableProperties: ["countryId"] as Array<keyof GetStatesInput>,
 };
 
 const getStates = createQuery<GetStatesInput, StateProvinceInfo[]>(

package/src/api-manager/services/cart/mutations/checkout.ts

@@ -1,11 +1,26 @@
 import { Cart, CheckoutInput } from "@/api-manager/schemas/cart.schema";
 import { createApiPath } from "../../create-query";
 import { useCreateMutation } from "../../create-mutation";
+import { deleteCartCookie } from "@/api-manager/lib/cart-cookie-handler";
+import getCart from "../queries/get-cart";
+import { useQueryClient } from "@tanstack/react-query";
 
 const apiPath = createApiPath("cart", "checkout");
 
 const useCheckout = () => {
-  return useCreateMutation<CheckoutInput, Cart>(apiPath);
+  const queryClient = useQueryClient();
+  return useCreateMutation<CheckoutInput, Cart>(apiPath, {
+    onSuccess: async (_data, variables) => {
+      // Delete old cart cookie
+      await deleteCartCookie();
+
+      queryClient.invalidateQueries({ queryKey: ["cart"] });
+    },
+    onError: (error) => {
+      console.error("Checkout failed:", error);
+      // Handle error appropriately, e.g., show a notification
+    },
+  });
 };
 
 export default useCheckout;

package/src/api-manager/services/cart/queries/get-cart-lines-inventory.ts

@@ -0,0 +1,15 @@
+import { ProductWarehouseInventoryInformation } from "@msdyn365-commerce/retail-proxy";
+import { InventorySearchCartLinesCriteriaInput } from "@/api-manager/schemas/cart.schema";
+import { createApiPath, createQuery } from "../../create-query";
+
+const apiPath = createApiPath("cart", "getCartLinesInventory");
+
+const getCartLinesInventory = createQuery<
+  InventorySearchCartLinesCriteriaInput,
+  ProductWarehouseInventoryInformation
+>(apiPath, {
+  queryKey: "cart-lines-Inventory",
+  disableProperties: ["allDimensionsSelected", "searchCriteria"],
+});
+
+export default getCartLinesInventory;

package/src/api-manager/services/create-extension-query.ts

@@ -0,0 +1,26 @@
+import { QueryFunction } from "@tanstack/react-query";
+
+/**
+ * This is a wrapper function for building an extension query.
+ * We don't require full-blown api-manager instance for extensions,
+ * because there is no data switching. Also not exporting all the react-query
+ * methods to keep the code flexible and adaptable for projects. This wrapper
+ * handles client side mutex to prevent multiple requests firing after refresh
+ * token has been found to be expired.
+ *
+ * During development, any additional hooks, events and extensions can be added to
+ * this function without affecting project.
+ *
+ * @param queryKey
+ * @param queryFn
+ * @returns
+ */
+const buildQueryData = <TQueryFnData = unknown, TQueryFnInput = unknown>(
+  queryKey: string,
+  queryFn: QueryFunction<TQueryFnData>,
+) => {
+  // TODO: insert mutex stuff here
+  return { queryKey: [queryKey], queryFn };
+};
+
+export default buildQueryData;