@evenicanpm/storefront-core 1.0.0-alpha

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

@@ -0,0 +1,30 @@
+import z from "zod";
+import {
+  salesLineSchema,
+  salesOrderSchema,
+  searchLocationSchema,
+  simpleProductSchema,
+} from "./d365.schema";
+
+const getSalesOrderDetailsInput = z.object({
+  transactionId: z.string(),
+  searchLocation: searchLocationSchema.optional(),
+});
+
+const salesOrderInput = z.object({
+  id: z.string(),
+});
+
+const extendedSalesLineSchema = salesLineSchema.extend({
+  Product: simpleProductSchema.optional(),
+});
+const extendedSalesOrderSchema = salesOrderSchema
+  .omit({ SalesLines: true })
+  .extend({ SalesLines: extendedSalesLineSchema.array().optional() });
+
+export type GetSalesOrderDetailsInput = z.infer<
+  typeof getSalesOrderDetailsInput
+>;
+export type SalesOrderInput = z.infer<typeof salesOrderInput>;
+export type SalesOrder = z.infer<typeof extendedSalesOrderSchema>;
+export type SalesLine = z.infer<typeof extendedSalesLineSchema>;

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

@@ -0,0 +1,32 @@
+import {
+  channelConfigurationSchema,
+  deliveryModeTypeFilterSchema,
+  deliveryOptionSchema,
+  orgUnitLocationSchema,
+  queryResultSettingsSchema,
+  searchAreaSchema,
+  storeHoursSchema,
+} from "./d365.schema";
+import z from "zod";
+
+const getOrgUnitLocationsByAreaInput = z.object({
+  queryResultSettings: queryResultSettingsSchema,
+  searchArea: searchAreaSchema,
+  deliveryModeTypeFilter: deliveryModeTypeFilterSchema.optional(),
+});
+
+const orgUnitLocationReturnType = z.object({
+  location: orgUnitLocationSchema,
+  storeHours: storeHoursSchema,
+  pickupOptions: deliveryOptionSchema.array().optional(),
+});
+
+export type OrgUnitLocation = z.infer<typeof orgUnitLocationSchema>;
+export type OrgUnitLocationReturnType = z.infer<
+  typeof orgUnitLocationReturnType
+>;
+export type GetOrgUnitLocationsByAreaInput = z.infer<
+  typeof getOrgUnitLocationsByAreaInput
+>;
+export type ChannelConfiguration = z.infer<typeof channelConfigurationSchema>;
+export type DeliveryOptionsSchema = z.infer<typeof deliveryOptionSchema>;

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

@@ -0,0 +1,140 @@
+import z from "zod";
+import {
+  categorySchema,
+  commercePropertySchema,
+  productRefinerSchema,
+  productSearchResultSchema,
+  queryResultSettingsSchema,
+  searchAreaSchema,
+} from "./d365.schema";
+import {
+  AttributeValue,
+  ProductDimensionValueInventoryAvailability,
+  SimpleProduct,
+  ProductRefinerValue,
+} from "@msdyn365-commerce/retail-proxy";
+
+// e4 review
+const reviewSchema = z.object({
+  Body: z.string().optional(),
+  Rating: z.number().optional(),
+  Title: z.string().optional(),
+  Created: z.string().optional(),
+  ProductId: z.string().optional(),
+  ContactId: z.string().optional(),
+  contact: z
+    .object({
+      firstName: z.string().optional(),
+      lastName: z.string().optional(),
+    })
+    .optional(),
+});
+
+/**
+ * Using this schema instead of the
+ * D365 schema to avoid unnecessary properties
+ * that are not provided by the E4 API.
+ * Add properties as needed.
+ */
+export const productSchema = z.object({
+  ItemId: z.string(), // sku?
+  RecordId: z.number(),
+  Name: z.string(),
+  Price: z.number().optional(),
+  BasePrice: z.number().optional(),
+  Description: z.string().optional(),
+  PrimaryImageUrl: z.string().or(z.null()).optional(), // adding a null for nextjs/image component
+  Variants: z.array(z.any()).optional(),
+  // required by E4
+  UnitOfMeasureId: z.string().optional(),
+  // ItemCode: z.string().optional(), // a SKU, does D365 have something like this? Keeping separate for now.
+  Reviews: z.array(reviewSchema).optional(),
+  categoryFilter: z.string().optional(),
+  ExtensionProperties: z.array(commercePropertySchema).optional(),
+});
+
+export const productWCategorySchema = productSchema.extend({
+  Category: categorySchema.optional(),
+});
+
+export const getProductByIdInput = z.object({
+  id: z.number().or(z.string()),
+});
+
+export const getRelatedProductsInput = z.object({
+  id: z.number(),
+});
+
+export const getProductByIdsInput = z.object({
+  id: z.union([z.number().array(), z.string().array()]),
+});
+
+export const getDimensionsInput = z.object({
+  id: z.number(),
+});
+
+export const searchProductsInput = z.object({
+  searchText: z.string().optional(),
+  category: z.number().optional(),
+  itemIds: z.string().array().optional(),
+});
+export const searchByCriteriaInput = z.object({
+  categoryId: z.number().optional(),
+  searchState: z.object({
+    queryResultSettings: queryResultSettingsSchema,
+    refinement: z.custom<ProductRefinerValue>().array(),
+    searchTerm: z.string().optional(),
+  }),
+});
+
+export const categoryFilterInput = z.object({
+  categoryId: z.number(),
+  searchState: z.any().optional(),
+  categoryFilterString: z.string().optional(),
+  pageSize: z.number().optional(),
+  currentPage: z.number().optional(),
+  sort: z
+    .object({
+      field: z.string(),
+      direction: z.string(),
+    })
+    .optional(),
+  refiners: z.number().array().optional(),
+});
+
+const searchByCriteriaResponse = z.object({
+  products: productSearchResultSchema.array(),
+  refiners: productRefinerSchema.array(),
+  count: z.number(),
+});
+
+const InventorySearchCriteriaInput = z.object({
+  searchCriteria: z.object({
+    defaultWarehouseOnly: z.boolean(),
+    productIds: z.number().array(),
+    searchArea: searchAreaSchema.optional(),
+  }),
+  allDimensionsSelected: z.boolean(),
+});
+
+// entities
+export type Product = z.infer<typeof productSchema>;
+export type ProductDetails = SimpleProduct & {
+  DimensionValues: ProductDimensionValueInventoryAvailability[][];
+  Attributes: AttributeValue[];
+  Images: string[];
+};
+export type ProductWCategory = z.infer<typeof productWCategorySchema>;
+export type Review = z.infer<typeof reviewSchema>;
+// inputs
+export type GetProductByIdInput = z.infer<typeof getProductByIdInput>;
+export type GetProductByIdsInput = z.infer<typeof getProductByIdsInput>;
+export type searchProductsInput = z.infer<typeof searchProductsInput>;
+export type GetRelatedProductsInput = z.infer<typeof getRelatedProductsInput>;
+export type CategoryFilterInput = z.infer<typeof categoryFilterInput>;
+export type GetDimensionsInput = z.infer<typeof getDimensionsInput>;
+export type SearchByCriteriaInput = z.infer<typeof searchByCriteriaInput>;
+export type SearchByCriteriaResponse = z.infer<typeof searchByCriteriaResponse>;
+export type InventorySearchCriteriaInput = z.infer<
+  typeof InventorySearchCriteriaInput
+>;

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

@@ -0,0 +1,17 @@
+import z from "zod";
+import { extendedCartSchema } from "./cart.schema";
+import { extendedCustomerSchema } from "./user.schema";
+
+export const sessionSchema = z.object({
+  Id: z.string().optional(),
+  User: extendedCustomerSchema.optional(),
+  Cart: extendedCartSchema.optional(),
+});
+
+export const sessionInitInput = z.object({
+  accessToken: z.string(),
+  email: z.string(),
+});
+
+export type Session = z.infer<typeof sessionSchema>;
+export type SessionInitInput = z.infer<typeof sessionInitInput>;

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

@@ -0,0 +1,14 @@
+import z from "zod";
+import { customerSchema } from "./d365.schema";
+
+export const userCountsSchema = z.object({
+  orderCount: z.number().optional(),
+  addressCount: z.number().optional(),
+});
+
+export const extendedCustomerSchema = customerSchema.extend({
+  DefaultShippingAddressId: z.string().optional(),
+});
+
+export type User = z.infer<typeof extendedCustomerSchema>;
+export type UserCounts = z.infer<typeof userCountsSchema>;

package/src/api-manager/services/address/mutations/create-address.ts

@@ -0,0 +1,22 @@
+import { Address } from "@/api-manager/schemas/address.schema";
+import { useQueryClient } from "@tanstack/react-query";
+import { createApiPath } from "../../create-query";
+import { useCreateMutation } from "../../create-mutation";
+
+const apiPath = createApiPath("address", "createAddress");
+
+const useCreateAddress = () => {
+  const queryClient = useQueryClient();
+
+  return useCreateMutation<Address, Address>(apiPath, {
+    onSuccess: () => {
+      queryClient.invalidateQueries({ queryKey: ["me"] });
+      queryClient.invalidateQueries({ queryKey: ["user-counts"] });
+    },
+    onError: (error) => {
+      console.error("Failed to create address:", error);
+    },
+  });
+};
+
+export default useCreateAddress;

package/src/api-manager/services/address/mutations/delete-address.ts

@@ -0,0 +1,21 @@
+import { useQueryClient } from "@tanstack/react-query";
+import { createApiPath } from "../../create-query";
+import { useCreateMutation } from "../../create-mutation";
+
+const apiPath = createApiPath("address", "deleteAddress");
+
+const useDeleteAddress = () => {
+  const queryClient = useQueryClient();
+
+  return useCreateMutation<string, void>(apiPath, {
+    onSuccess: () => {
+      queryClient.invalidateQueries({ queryKey: ["me"] });
+      queryClient.invalidateQueries({ queryKey: ["user-counts"] });
+    },
+    onError: (error) => {
+      console.error("Failed to delete address:", error);
+    },
+  });
+};
+
+export default useDeleteAddress;

package/src/api-manager/services/address/mutations/get-delivery-options.ts

@@ -0,0 +1,22 @@
+import { DeliveryOption } from "@msdyn365-commerce/retail-proxy";
+import { GetDeliveryOptionsInput } from "@/api-manager/schemas/address.schema";
+import { useQueryClient } from "@tanstack/react-query";
+import { createApiPath } from "../../create-query";
+import { useCreateMutation } from "../../create-mutation";
+
+const apiPath = createApiPath("address", "getDeliveryOptions");
+
+const useGetDeliveryOptions = () => {
+  const queryClient = useQueryClient();
+
+  return useCreateMutation<GetDeliveryOptionsInput, DeliveryOption[]>(apiPath, {
+    onSuccess: (result, input) => {
+      queryClient.setQueryData(["deliveryOptions", input], result);
+    },
+    onError: (error) => {
+      console.error("Failed to fetch delivery options:", error);
+    },
+  });
+};
+
+export default useGetDeliveryOptions;

package/src/api-manager/services/address/mutations/update-address.ts

@@ -0,0 +1,21 @@
+import { Address } from "@/api-manager/schemas/address.schema";
+import { useQueryClient } from "@tanstack/react-query";
+import { createApiPath } from "../../create-query";
+import { useCreateMutation } from "../../create-mutation";
+
+const apiPath = createApiPath("address", "updateAddress");
+
+const useUpdateAddress = () => {
+  const queryClient = useQueryClient();
+
+  return useCreateMutation<Address, Address>(apiPath, {
+    onSuccess: () => {
+      queryClient.invalidateQueries({ queryKey: ["me"] });
+    },
+    onError: (error) => {
+      console.error("Failed to update address:", error);
+    },
+  });
+};
+
+export default useUpdateAddress;

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

@@ -0,0 +1,16 @@
+import { createQuery } from "../../create-query";
+import { GetCountriesInput } from "@/api-manager/schemas/address.schema";
+import { CountryRegionInfo } from "@msdyn365-commerce/retail-proxy";
+import { createApiPath } from "../../create-query";
+
+const apiPath = createApiPath("address", "getCountries");
+const config = {
+  queryKey: "countries",
+};
+
+const getCountries = createQuery<GetCountriesInput, CountryRegionInfo[]>(
+  apiPath,
+  config,
+);
+
+export default getCountries;

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

@@ -0,0 +1,16 @@
+import { GetStatesInput } from "@/api-manager/schemas/address.schema";
+import { StateProvinceInfo } from "@msdyn365-commerce/retail-proxy";
+import { createQuery, createApiPath } from "../../create-query";
+
+const apiPath = createApiPath("address", "getStates");
+const config = {
+  queryKey: "states",
+  disablePropertis: ["countryId"],
+};
+
+const getStates = createQuery<GetStatesInput, StateProvinceInfo[]>(
+  apiPath,
+  config,
+);
+
+export default getStates;

package/src/api-manager/services/cart/mutations/add-discount-code.ts

@@ -0,0 +1,21 @@
+import {
+  ManageDiscountCodeInput,
+  Cart,
+} from "@/api-manager/schemas/cart.schema";
+import { useQueryClient } from "@tanstack/react-query";
+import getCart from "../queries/get-cart";
+import { createApiPath } from "../../create-query";
+import { useCreateMutation } from "../../create-mutation";
+
+const apiPath = createApiPath("cart", "addDiscountCode");
+
+const useAddDiscountCode = () => {
+  const queryClient = useQueryClient();
+  return useCreateMutation<ManageDiscountCodeInput, Cart>(apiPath, {
+    onSuccess: async (result) => {
+      await getCart.setQueryData(queryClient, result);
+    },
+  });
+};
+
+export default useAddDiscountCode;

package/src/api-manager/services/cart/mutations/add-to-cart.ts

@@ -0,0 +1,53 @@
+import { AddToCartInput, Cart } from "@/api-manager/schemas/cart.schema";
+import { useNotification } from "@/components/Notifications/use-notification";
+import { useTranslations } from "next-intl";
+import { useCreateMutation } from "../../create-mutation";
+import getCart from "../queries/get-cart";
+import { createApiPath } from "../../create-query";
+import { useQueryClient } from "@tanstack/react-query";
+
+const apiPath = createApiPath("cart", "addToCart");
+
+const useAddToCart = () => {
+  const { setNotification } = useNotification();
+  const t = useTranslations("Cart.Messages");
+  const queryClient = useQueryClient();
+
+  return useCreateMutation<AddToCartInput, Cart>(apiPath, {
+    onSuccess: async (result, input) => {
+      await getCart.setQueryData(queryClient, result);
+
+      // Handle single cart line
+      if (input.cartLine.length === 1) {
+        const cartLine = result?.CartLines?.find(
+          (line) => line.ItemId === input.cartLine[0].ItemId,
+        );
+
+        if (cartLine) {
+          setNotification({
+            message: t("cartAddSuccess", { item: cartLine?.Product?.Name }),
+            severity: "success",
+            type: "cart",
+          });
+          return;
+        }
+      }
+
+      // Handle multiple cart lines
+      setNotification({
+        message: t("cartAddSuccessMulti", { count: input.cartLine.length }),
+        severity: "success",
+        type: "cart",
+      });
+    },
+    onError: () => {
+      setNotification({
+        message: t("cartAddError"),
+        severity: "error",
+        type: "cart",
+      });
+    },
+  });
+};
+
+export default useAddToCart;

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

@@ -0,0 +1,11 @@
+import { Cart, CheckoutInput } from "@/api-manager/schemas/cart.schema";
+import { createApiPath } from "../../create-query";
+import { useCreateMutation } from "../../create-mutation";
+
+const apiPath = createApiPath("cart", "checkout");
+
+const useCheckout = () => {
+  return useCreateMutation<CheckoutInput, Cart>(apiPath);
+};
+
+export default useCheckout;

package/src/api-manager/services/cart/mutations/delete-cart-line.ts

@@ -0,0 +1,18 @@
+import { Cart, DeleteCartLineInput } from "@/api-manager/schemas/cart.schema";
+import { useQueryClient } from "@tanstack/react-query";
+import getCart from "../queries/get-cart";
+import { useCreateMutation } from "../../create-mutation";
+import { createApiPath } from "../../create-query";
+
+const apiPath = createApiPath("cart", "deleteCartLine");
+
+const useDeleteCartLine = () => {
+  const queryClient = useQueryClient();
+  return useCreateMutation<DeleteCartLineInput, Cart>(apiPath, {
+    onSuccess: async (result) => {
+      await getCart.setQueryData(queryClient, result);
+    },
+  });
+};
+
+export default useDeleteCartLine;

package/src/api-manager/services/cart/mutations/get-payment-accept-result.ts

@@ -0,0 +1,20 @@
+import { CardPaymentAcceptResult } from "@msdyn365-commerce/retail-proxy";
+import { RetrieveCardPaymentAcceptResultInput } from "@/api-manager/schemas/cart.schema";
+import { useQueryClient } from "@tanstack/react-query";
+import { createApiPath } from "../../create-query";
+import { useCreateMutation } from "../../create-mutation";
+
+const apiPath = createApiPath("cart", "retrieveCardPaymentAcceptResult");
+const usePaymentAcceptResult = () => {
+  const queryClient = useQueryClient();
+  return useCreateMutation<
+    RetrieveCardPaymentAcceptResultInput,
+    CardPaymentAcceptResult
+  >(apiPath, {
+    onSuccess: (result, input) => {
+      queryClient.setQueryData(["paymentAcceptResult", input.cartId], result);
+    },
+  });
+};
+
+export default usePaymentAcceptResult;

package/src/api-manager/services/cart/mutations/remove-cart-line-delivery-mode.ts

@@ -0,0 +1,24 @@
+import {
+  Cart,
+  RemoveCartLineDeliveryModeInput,
+} from "@/api-manager/schemas/cart.schema";
+import { useQueryClient } from "@tanstack/react-query";
+import getCart from "../queries/get-cart";
+import { createApiPath } from "../../create-query";
+import { useCreateMutation } from "../../create-mutation";
+
+const apiPath = createApiPath("cart", "removeLineDeliveryMode");
+
+const useRemoveCartLineDeliveryMode = () => {
+  const queryClient = useQueryClient();
+  return useCreateMutation<RemoveCartLineDeliveryModeInput, Cart>(apiPath, {
+    onSuccess: async (result) => {
+      await getCart.setQueryData(queryClient, result);
+    },
+    onError: (error) => {
+      console.error(error);
+    },
+  });
+};
+
+export default useRemoveCartLineDeliveryMode;

package/src/api-manager/services/cart/mutations/remove-discount-code.ts

@@ -0,0 +1,21 @@
+import {
+  Cart,
+  ManageDiscountCodeInput,
+} from "@/api-manager/schemas/cart.schema";
+import getCart from "../queries/get-cart";
+import { createApiPath } from "../../create-query";
+import { useCreateMutation } from "../../create-mutation";
+import { useQueryClient } from "@tanstack/react-query";
+
+const apiPath = createApiPath("cart", "removeDiscountcode");
+
+const useRemoveDiscountcode = () => {
+  const queryClient = useQueryClient();
+  return useCreateMutation<ManageDiscountCodeInput, Cart>(apiPath, {
+    onSuccess: async (result) => {
+      await getCart.setQueryData(queryClient, result);
+    },
+  });
+};
+
+export default useRemoveDiscountcode;

package/src/api-manager/services/cart/mutations/update-cart-line-delivery-mode.ts

@@ -0,0 +1,24 @@
+import {
+  Cart,
+  UpdateCartLineDeliveryModeInput,
+} from "@/api-manager/schemas/cart.schema";
+import getCart from "../queries/get-cart";
+import { createApiPath } from "../../create-query";
+import { useCreateMutation } from "../../create-mutation";
+import { useQueryClient } from "@tanstack/react-query";
+
+const apiPath = createApiPath("cart", "updateLineDeliveryMode");
+
+const useUpdateCartLineDeliveryMode = () => {
+  const queryClient = useQueryClient();
+  return useCreateMutation<UpdateCartLineDeliveryModeInput, Cart>(apiPath, {
+    onSuccess: async (result) => {
+      await getCart.setQueryData(queryClient, result);
+    },
+    onError: (error) => {
+      console.error("Failed to update cart line delivery mode:", error);
+    },
+  });
+};
+
+export default useUpdateCartLineDeliveryMode;

package/src/api-manager/services/cart/mutations/update-cart-lines.ts

@@ -0,0 +1,21 @@
+import { UpdateCartLineInput, Cart } from "@/api-manager/schemas/cart.schema";
+import getCart from "../queries/get-cart";
+import { createApiPath } from "../../create-query";
+import { useCreateMutation } from "../../create-mutation";
+import { useQueryClient } from "@tanstack/react-query";
+
+const apiPath = createApiPath("cart", "updateCartLines");
+
+const useUpdateCartLines = () => {
+  const queryClient = useQueryClient();
+  return useCreateMutation<UpdateCartLineInput, Cart>(apiPath, {
+    onSuccess: async (result) => {
+      await getCart.setQueryData(queryClient, result);
+    },
+    onError: (error) => {
+      console.error("Failed to update cart lines:", error);
+    },
+  });
+};
+
+export default useUpdateCartLines;

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

@@ -0,0 +1,21 @@
+import { Cart, UpdateCartInput } from "@/api-manager/schemas/cart.schema";
+import getCart from "../queries/get-cart";
+import { createApiPath } from "../../create-query";
+import { useCreateMutation } from "../../create-mutation";
+import { useQueryClient } from "@tanstack/react-query";
+
+const apiPath = createApiPath("cart", "updateCart");
+
+const useUpdateCart = () => {
+  const queryClient = useQueryClient();
+  return useCreateMutation<UpdateCartInput, Cart>(apiPath, {
+    onSuccess: async (result) => {
+      await getCart.setQueryData(queryClient, result);
+    },
+    onError: (error) => {
+      console.error("Failed to update cart:", error);
+    },
+  });
+};
+
+export default useUpdateCart;

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

@@ -0,0 +1,12 @@
+import { createQuery } from "../../create-query";
+import { Cart } from "@/api-manager/schemas/cart.schema";
+import { createApiPath } from "../../create-query";
+
+const apiPath = createApiPath("cart", "getCart");
+
+const getCart = createQuery<null, Cart>(apiPath, {
+  queryKey: "cart",
+  //config
+});
+
+export default getCart;

package/src/api-manager/services/cart/queries/get-payment-accept-point.ts

@@ -0,0 +1,18 @@
+import { CardPaymentAcceptPoint } from "@msdyn365-commerce/retail-proxy";
+import { createQuery, createApiPath } from "../../create-query";
+import { GetCardPaymentAcceptPointInput } from "@/api-manager/schemas/cart.schema";
+
+const apiPath = createApiPath("cart", "getCardAcceptPoint");
+const config = {
+  queryKey: "paymentAcceptPoint",
+  disableProperties: ["cartId", "totalAmount", "isClient"] as Array<
+    keyof GetCardPaymentAcceptPointInput
+  >,
+};
+
+const getPaymentAcceptPoint = createQuery<
+  GetCardPaymentAcceptPointInput,
+  CardPaymentAcceptPoint
+>(apiPath, config);
+
+export default getPaymentAcceptPoint;

package/src/api-manager/services/categories/queries/get-categories.ts

@@ -0,0 +1,8 @@
+import { CategoryHierarchy } from "../../../lib/category-helpers";
+import { createApiPath, createQuery } from "../../create-query";
+
+const apiPath = createApiPath("categories", "getCategories");
+
+const getCategories = createQuery<null, CategoryHierarchy[]>(apiPath);
+
+export default getCategories;