@evenicanpm/storefront-core 1.0.1 → 1.0.3

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

@@ -0,0 +1,161 @@
+// Interfaces
+import { Category as E4Category } from "../graphqlRequestSdk";
+import { Category } from "@msdyn365-commerce/retail-proxy";
+import { CategoryHierarchy } from "@/lib/category-helpers";
+
+interface TransformedCategoryNode extends Category {
+  Slug: string;
+  Url: string;
+  NeutralizedName: string;
+  Children?: TransformedCategoryNode[];
+  ParentCategory?: number;
+}
+
+export const categoryTransformValidate = (
+  rawCategories: E4Category[],
+  rootParentId = 1,
+  urlPrefix = "e4",
+): CategoryHierarchy[] => {
+  function generateSlug(name: string): string {
+    if (!name) return "";
+    return name
+      .toLowerCase()
+      .replace(/\s+/g, "-")
+      .replace(/[^\w-]+/g, "")
+      .replace(/--+/g, "-")
+      .replace(/^-+/, "")
+      .replace(/-+$/, "");
+  }
+
+  function createTransformedNode(
+    rawCategory: E4Category,
+  ): TransformedCategoryNode | null {
+    let recordIdNum: number;
+    try {
+      recordIdNum = parseInt(String(rawCategory.id), 10);
+      if (isNaN(recordIdNum)) throw new Error("Invalid RecordId");
+    } catch (e) {
+      console.warn(`Skipping category due to invalid id:`, rawCategory);
+      return null;
+    }
+
+    const categoryName = rawCategory.name || "Unnamed Category";
+    const slug = generateSlug(categoryName);
+    let parentIdNum: number | undefined = undefined;
+    if (rawCategory.parentId != null) {
+      const parsedParentId = parseInt(String(rawCategory.parentId), 10);
+      if (!isNaN(parsedParentId)) parentIdNum = parsedParentId;
+      else
+        console.warn(
+          `Invalid parentId format for id ${recordIdNum}:`,
+          rawCategory.parentId,
+        );
+    }
+
+    const node: TransformedCategoryNode = {
+      RecordId: recordIdNum,
+      Name: categoryName,
+      ParentCategory: parentIdNum,
+      DisplayOrder: 0,
+      LocalizedDescription: categoryName,
+      Images: [
+        {
+          Uri: `Categories/${categoryName}.png`,
+          IsDefault: false,
+          IsSelfHosted: false,
+          Priority: 0,
+          IsAdditionalMedia: false,
+          MediaTypeValue: 0,
+          DisplayOrder: 0,
+          IsApplicableForChildEntities: false,
+          ExtensionProperties: [],
+        },
+      ],
+      NameTranslations: [
+        { Language: "en-us", Text: categoryName, ExtensionProperties: [] },
+      ],
+      ExtensionProperties: [],
+      NeutralizedName: categoryName,
+      Slug: slug,
+      Url: "",
+      Children: [],
+    };
+    return node;
+  }
+
+  function calculateUrls(
+    categoryNode: TransformedCategoryNode,
+    basePath: string,
+    prefix: string,
+  ): void {
+    const currentPath = basePath
+      ? `${basePath}/${categoryNode.Slug}`
+      : `${prefix}/${categoryNode.Slug}`;
+    categoryNode.Url = `${currentPath}/${categoryNode.RecordId}`;
+    // Check if Children exists before iterating
+    if (categoryNode?.Children && categoryNode?.Children?.length > 0) {
+      categoryNode.Children.forEach((child: TransformedCategoryNode) =>
+        calculateUrls(child, currentPath, prefix),
+      );
+    }
+  }
+
+  function removeEmptyChildren(node: TransformedCategoryNode): void {
+    if (node.Children) {
+      if (node.Children.length === 0) {
+        delete node.Children;
+      } else {
+        node.Children.forEach(removeEmptyChildren);
+      }
+    }
+  }
+
+  if (!rawCategories || !Array.isArray(rawCategories)) {
+    console.error(
+      "Invalid input received by categoryTransformValidate: must be an array.",
+      rawCategories,
+    );
+    return [];
+  }
+
+  const categoryMap = new Map<number, TransformedCategoryNode>();
+  const rootNodes: TransformedCategoryNode[] = [];
+
+  rawCategories.forEach((rawCat: E4Category) => {
+    const transformedNode = createTransformedNode(rawCat);
+    if (transformedNode)
+      categoryMap.set(transformedNode.RecordId, transformedNode);
+  });
+
+  categoryMap.forEach((node: TransformedCategoryNode) => {
+    const parentId = node.ParentCategory;
+    if (parentId === rootParentId) rootNodes.push(node);
+    else if (parentId !== undefined && categoryMap.has(parentId)) {
+      const parentNode = categoryMap.get(parentId);
+      if (parentNode) {
+        if (!parentNode.Children) {
+          parentNode.Children = [];
+        }
+        parentNode.Children.push(node);
+        parentNode.Children.sort(
+          (a, b) =>
+            (a.DisplayOrder ?? 0) - (b.DisplayOrder ?? 0) ||
+            (a.Name ?? "").localeCompare(b.Name ?? ""),
+        );
+      }
+    }
+  });
+
+  rootNodes.forEach((rootNode: TransformedCategoryNode) =>
+    calculateUrls(rootNode, "", urlPrefix),
+  );
+  rootNodes.sort(
+    (a, b) =>
+      (a.DisplayOrder ?? 0) - (b.DisplayOrder ?? 0) ||
+      (a.Name ?? "").localeCompare(b.Name ?? ""),
+  );
+
+  rootNodes.forEach(removeEmptyChildren);
+
+  return rootNodes as CategoryHierarchy[];
+};

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

@@ -1,16 +1,13 @@
 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 "./user/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";
+import session from "./session/e4-session.datasource";
+import cart from "./cart/e4-cart.datasource";
+import order from "./order/e4-order.datasource";
+import address from "./address/e4-address.datasource";
+import product from "./product/e4-product.datasource";
+import organization from "./organization/e4-organization.datasource";
+import categories from "./categories/e4-categories.datasource";
 
 const E4Datasource: PrimaryDatasource = {
   name: "e4",
@@ -21,35 +18,7 @@ const E4Datasource: PrimaryDatasource = {
   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;
-    },
-  },
+  categories,
 };
 
 export default E4Datasource;