[Fix] - Improve Linx Stability

linx/actions/auction/addBid.ts

@@ -1,3 +1,5 @@
+import { logger } from "@deco/deco/o11y";
+import { cleanResponse } from "../../../utils/http.ts";
 import type { AppContext } from "../../mod.ts";
 import { CartOperation } from "../../utils/types/basket.ts";
 
@@ -25,7 +27,24 @@ const action = async (
     },
   );
 
-  const data = await response.json();
+  const data = await cleanResponse<CartOperation>(response);
+
+  if (typeof data !== "object") {
+    logger.error(`Failed to parse response from linx as JSON: ${data}`);
+    return {
+      Errors: [],
+      IsValid: false,
+      RefreshBasket: false,
+      ResponseCallBack: {
+        Code: "0",
+        Parameters: [],
+        Value: "",
+      },
+      SuccessMessage: null,
+      Url: null,
+      Warnings: [],
+    };
+  }
 
   return data;
 };

linx/loaders/auction/ListBids.ts

@@ -1,6 +1,7 @@
+import { logger } from "@deco/deco/o11y";
 import type { AppContext } from "../../../linx/mod.ts";
-import { nullOnNotFound } from "../../../utils/http.ts";
-import { Bids } from "../../utils/types/ListBidsJSON.ts";
+import { cleanResponse, nullOnNotFound } from "../../../utils/http.ts";
+import { Bids, WebPage } from "../../utils/types/ListBidsJSON.ts";
 
 /**
  * @title Linx Integration
@@ -26,7 +27,12 @@ const bidsloader = async (
     return null;
   }
 
-  const auction = await response.json();
+  const auction = await cleanResponse<WebPage>(response);
+
+  if (typeof auction !== "object") {
+    logger.error(`Failed to parse response from linx as JSON: ${auction}`);
+    return null;
+  }
 
   return auction.Bids;
 };

linx/loaders/auction/apiList.ts

@@ -1,5 +1,7 @@
 import { Auction } from "../../utils/types/auctionAPI.ts";
 import type { AppContext } from "../../../linx/mod.ts";
+import { cleanResponse } from "../../../utils/http.ts";
+import { logger } from "@deco/deco/o11y";
 
 /**
  * @title Linx Integration
@@ -12,22 +14,32 @@ const loader = async (
 ): Promise<Auction[] | null> => {
   const { layer } = ctx;
 
-  const responsePromise = await layer
-    ["POST /v1/Catalog/API.svc/web/SearchProductAuctions"](
-      {},
-      // @ts-ignore body is required
-      { body: {} },
-    );
+  try {
+    const responsePromise = await layer
+      ["POST /v1/Catalog/API.svc/web/SearchProductAuctions"](
+        {},
+        // @ts-ignore body is required
+        { body: {} },
+      );
 
-  return await responsePromise.json();
-};
+    const response = await cleanResponse<Auction[]>(responsePromise);
+
+    if (typeof response !== "object") {
+      logger.error(`Failed to parse response from linx as JSON: ${response}`);
+      return null;
+    }
 
-export const cache = "stale-while-revalidate";
+    return response;
+  } catch (error) {
+    console.error("Linx auction API list error", error);
+    throw error;
+  }
+};
 
-export const cacheKey = (_props: unknown, req: Request, _ctx: AppContext) => {
-  const url = new URL(req.url);
-  url.pathname = "/v1/Catalog/API.svc/web/SearchProductAuctions";
-  return url.href;
+export const cache = {
+  maxAge: 60, // 1 min
 };
 
+export const cacheKey = () => "/v1/Catalog/API.svc/web/SearchProductAuctions";
+
 export default loader;

linx/loaders/auction/list.ts

@@ -1,8 +1,10 @@
+import { logger } from "@deco/deco/o11y";
 import type { AppContext } from "../../../linx/mod.ts";
-import { nullOnNotFound } from "../../../utils/http.ts";
+import { cleanResponse, nullOnNotFound } from "../../../utils/http.ts";
 import { isAuctionModel } from "../../utils/paths.ts";
 import { toAuction, toFilters } from "../../utils/transform.ts";
 import { AuctionListingPage } from "../../utils/types/auction.ts";
+import { WebPage } from "../../utils/types/gridProductsJSON.ts";
 
 /**
  * @title Linx Integration
@@ -24,14 +26,19 @@ const loader = async (
     return null;
   }
 
-  const auctions = await response.json();
+  const auctions = await cleanResponse<WebPage>(response);
+
+  if (typeof auctions !== "object") {
+    logger.error(`Failed to parse response from linx as JSON: ${auctions}`);
+    return null;
+  }
 
   if (!auctions || !isAuctionModel(auctions)) {
     throw new Error("/leilao.json returned another model than Auction");
   }
 
-  const products = auctions.Model.ProductAuctions.map((auction) =>
-    toAuction(auction, { cdn })
+  const products = auctions.Model.ProductAuctions.map((auction, index) =>
+    toAuction(auction, { cdn }, auctions.Model.Grid.Products[index])
   );
   const facets = toFilters(auctions.Model.Grid.Facets, url);
   const pageCount = auctions.Model.Grid.PageCount;

linx/loaders/path.ts

@@ -1,4 +1,6 @@
+import { logger } from "@deco/deco/o11y";
 import { STALE } from "../../utils/fetch.ts";
+import { cleanResponse } from "../../utils/http.ts";
 import type { AppContext } from "../mod.ts";
 import type { API } from "../utils/client.ts";
 import { redirect } from "@deco/deco";
@@ -58,6 +60,14 @@ async function loader(
     const redirectUrl = new URL(redirectUrlRaw);
     throw redirect(redirectUrl);
   }
-  return response.json();
+
+  const data = await cleanResponse<API["GET /*splat"]["response"]>(response);
+
+  if (typeof data !== "object") {
+    logger.error(`Failed to parse response from linx as JSON: ${data}`);
+    return null;
+  }
+
+  return data;
 }
 export default loader;

linx/loaders/product/listingPage.ts

@@ -8,6 +8,16 @@ import {
   toProduct,
 } from "../../utils/transform.ts";
 
+export interface Props {
+  /**
+   * @ignore
+   * @maximum 2
+   */
+  retryCount?: number;
+}
+
+const MAX_ATTEMPTS = 1;
+
 const getPageInfo = ({ page, nbPages, recordPerPage, records, url }: {
   page: number;
   nbPages: number;
@@ -45,7 +55,7 @@ const getPageInfo = ({ page, nbPages, recordPerPage, records, url }: {
  * @description Product Listing Page loader
  */
 const loader = async (
-  _props: unknown,
+  { retryCount = 0 }: Props,
   req: Request,
   ctx: AppContext,
 ): Promise<ProductListingPage | null> => {
@@ -60,7 +70,12 @@ const loader = async (
     !forProducts ||
     !isGridProductsModel(forProducts)
   ) {
-    throw new Error("Expected GridProducts model");
+    if (retryCount <= MAX_ATTEMPTS) {
+      return ctx.invoke("linx/loaders/product/listingPage.ts", {
+        retryCount: retryCount + 1,
+      });
+    }
+    return null;
   }
 
   const {

linx/utils/transform.ts

@@ -10,6 +10,7 @@ import {
 import { DEFAULT_IMAGE } from "../../commerce/utils/constants.ts";
 import { CartResponse } from "./types/basketJSON.ts";
 import {
+  MediaGroup,
   Product as LinxProductGroupGridProductsJSON,
 } from "./types/gridProductsJSON.ts";
 import { NavigationInfo as ProductNavigation } from "./types/shared.ts";
@@ -458,10 +459,12 @@ export const toCart = (
 export const toAuction = (
   auction: ProductAuction,
   { cdn }: { cdn: string },
-): ProductAuction => {
+  product: LinxProductGroupGridProductsJSON,
+): ProductAuction & { MediaGroups: MediaGroup[] } => {
   return ({
     ...auction,
     ProductImage: new URL(auction.ProductImage, cdn).href,
+    MediaGroups: product.MediaGroups,
   });
 };
 

utils/http.ts

@@ -166,3 +166,51 @@ export const nullOnNotFound = (error: any) => {
   }
   throw error;
 };
+
+/**
+ * Clean function to process HTTP responses based on Content-Type
+ * @param {Response} response - The fetch response object
+ * @returns {Promise<object|string|Blob>} - Returns the response body converted to the appropriate format
+ */
+export async function cleanResponse<T>(response: Response): Promise<T> {
+  if (!response.ok) {
+    throw new Error(`HTTP Error! Status: ${response.status}`);
+  }
+
+  const contentType = response.headers.get("Content-Type") || "";
+
+  // deno-lint-ignore no-explicit-any
+  const contentHandlers: Record<string, () => Promise<any>> = {
+    "application/json": () => response.json(),
+    "text/": () => response.text(),
+    "image/": () => response.blob(),
+    "audio/": () => response.blob(),
+    "video/": () => response.blob(),
+    "application/octet-stream": () => response.blob(),
+  };
+
+  try {
+    // Find the appropriate handler based on content-type
+    const handlerKey = Object.keys(contentHandlers).find((type) =>
+      contentType.includes(type)
+    );
+
+    if (handlerKey) {
+      return await contentHandlers[handlerKey]();
+    }
+
+    // Fallback - try JSON first, then text
+    try {
+      return await response.json();
+    } catch {
+      return await response.text() as unknown as T;
+    }
+  } catch (error) {
+    console.error("Error processing response:", error);
+    throw new Error(
+      `Failed to process response: ${
+        error instanceof Error ? error.message : String(error)
+      }`,
+    );
+  }
+}