refactor: extract prices function to util, comments

Author: VariableVic

src/app/api/categories/[...handle]/route.ts

@@ -1,20 +1,24 @@
 import { NextRequest, NextResponse } from "next/server"
 import { initialize as initializeProductModule } from "@medusajs/product"
 import { ProductDTO } from "@medusajs/types/dist/product"
+import { IPricingModuleService } from "@medusajs/types"
 import { notFound } from "next/navigation"
 import { MedusaApp, Modules } from "@medusajs/modules-sdk"
+import { getPricesByPriceSetId } from "@lib/util/get-prices-by-price-set-id"
 
 /**
- * This endpoint uses the serverless Product Module to retrieve a category and its products by handle.
+ * This endpoint uses the serverless Product and Pricing Modules to retrieve a category and its products by handle.
  * The module connects directly to you Medusa database to retrieve and manipulate data, without the need for a dedicated server.
  * Read more about the Product Module here: https://docs.medusajs.com/modules/products/serverless-module
  */
 export async function GET(
   request: NextRequest,
   { params }: { params: Record<string, any> }
 ) {
+  // Initialize the Product Module
   const productService = await initializeProductModule()
 
+  // Extract the query parameters
   const searchParams = Object.fromEntries(request.nextUrl.searchParams)
   const { page, limit } = searchParams
 
@@ -24,6 +28,7 @@ export async function GET(
     categoryHandle.slice(0, index + 1).join("/")
   )
 
+  // Fetch the category by handle
   const product_categories = await productService
     .listCategories(
       {
@@ -45,17 +50,21 @@ export async function GET(
     return notFound()
   }
 
+  // Fetch the products by category id
   const {
     rows: products,
     metadata: { count },
   } = await getProductsByCategoryId(category.id, searchParams)
 
+  // Filter out unpublished products
   const publishedProducts: ProductDTO[] = products.filter(
     (product) => product.status === "published"
   )
 
+  // Calculate the next page
   const nextPage = parseInt(page) + parseInt(limit)
 
+  // Return the response
   return NextResponse.json({
     product_categories: Object.values(product_categories),
     response: {
@@ -66,6 +75,12 @@ export async function GET(
   })
 }
 
+/**
+ * This function uses the serverless Product and Pricing Modules to retrieve products by category id.
+ * @param category_id The category id
+ * @param params The query parameters
+ * @returns The products and metadata
+ */
 async function getProductsByCategoryId(
   category_id: string,
   params: Record<string, any>
@@ -75,22 +90,18 @@ async function getProductsByCategoryId(
 
   currency_code = currency_code && currency_code.toUpperCase()
 
+  // Initialize Remote Query with the Product and Pricing Modules
   const { query, modules } = await MedusaApp({
-    modulesConfig: [
-      {
-        module: Modules.PRODUCT,
-        path: "@medusajs/product",
-      },
-      {
-        module: Modules.PRICING,
-        path: "@medusajs/pricing",
-      },
-    ],
+    modulesConfig: {
+      [Modules.PRODUCT]: true,
+      [Modules.PRICING]: true,
+    },
     sharedResourcesConfig: {
       database: { clientUrl: process.env.POSTGRES_URL },
     },
   })
 
+  // Set the filters for the query
   const filters = {
     take: parseInt(params.limit) || 100,
     skip: parseInt(params.offset) || 0,
@@ -100,6 +111,7 @@ async function getProductsByCategoryId(
     currency_code,
   }
 
+  // Set the GraphQL query
   const productsQuery = `#graphql
     query($filters: Record, $take: Int, $skip: Int) {
       products(filters: $filters, take: $take, skip: $skip) {
@@ -147,33 +159,19 @@ async function getProductsByCategoryId(
       }
     }`
 
+  // Run the query
   const { rows, metadata } = await query(productsQuery, filters)
 
-  for (const product of rows) {
-    for (const variant of product.variants) {
-      const priceSetIds = variant.price.map((price) => price.price_set.id)
-
-      const prices = await modules.pricingService.calculatePrices(
-        { id: priceSetIds },
-        {
-          context: { currency_code },
-        }
-      )
-
-      const price = prices.find(
-        (price) => price.currency_code === currency_code
-      )
-
-      if (!price) continue
-
-      delete variant.price
-      variant.price = price
-      variant.calculated_price = price.amount
-    }
-  }
+  // Calculate prices
+  const productsWithPrices = await getPricesByPriceSetId({
+    products: rows,
+    currency_code,
+    pricingService: modules.pricingService as unknown as IPricingModuleService,
+  })
 
+  // Return the response
   return {
-    rows,
+    rows: productsWithPrices,
     metadata,
   }
 }

src/app/api/collections/[handle]/route.ts

@@ -4,6 +4,8 @@ import { notFound } from "next/navigation"
 import { initialize as initializeProductModule } from "@medusajs/product"
 import { MedusaApp, Modules } from "@medusajs/modules-sdk"
 import { ProductCollectionDTO, ProductDTO } from "@medusajs/types/dist/product"
+import { IPricingModuleService } from "@medusajs/types"
+import { getPricesByPriceSetId } from "@lib/util/get-prices-by-price-set-id"
 
 /**
  * This endpoint uses the serverless Product Module to retrieve a collection and its products by handle.
@@ -14,38 +16,47 @@ export async function GET(
   request: NextRequest,
   { params }: { params: Record<string, any> }
 ) {
+  // Initialize the Product Module
   const productService = await initializeProductModule()
 
+  // Extract the query parameters
   const { handle } = params
 
   const searchParams = Object.fromEntries(request.nextUrl.searchParams)
   const { page, limit } = searchParams
 
+  // Fetch the collections
   const collections = await productService.listCollections()
 
+  // Create a map of collections by handle
   const collectionsByHandle = new Map<string, ProductCollectionDTO>()
 
   for (const collection of collections) {
     collectionsByHandle.set(collection.handle, collection)
   }
 
+  // Fetch the collection by handle
   const collection = collectionsByHandle.get(handle)
 
   if (!collection) {
     return notFound()
   }
 
+  // Fetch the products by collection id
   const {
     rows: products,
     metadata: { count },
   } = await getProductsByCollectionId(collection.id, searchParams)
 
+  // Filter out unpublished products
   const publishedProducts: ProductDTO[] = products.filter(
     (product) => product.status === "published"
   )
 
+  // Calculate the next page
   const nextPage = parseInt(page) + parseInt(limit)
 
+  // Return the response
   return NextResponse.json({
     collections: [collection],
     response: {
@@ -56,6 +67,12 @@ export async function GET(
   })
 }
 
+/**
+ * This endpoint uses the serverless Product and Pricing Modules to retrieve a product list.
+ * @param collection_id The collection id to filter by
+ * @param params The query parameters
+ * @returns The products and metadata
+ */
 async function getProductsByCollectionId(
   collection_id: string,
   params: Record<string, any>
@@ -65,22 +82,18 @@ async function getProductsByCollectionId(
 
   currency_code = currency_code && currency_code.toUpperCase()
 
+  // Initialize Remote Query with the Product and Pricing Modules
   const { query, modules } = await MedusaApp({
-    modulesConfig: [
-      {
-        module: Modules.PRODUCT,
-        path: "@medusajs/product",
-      },
-      {
-        module: Modules.PRICING,
-        path: "@medusajs/pricing",
-      },
-    ],
+    modulesConfig: {
+      [Modules.PRODUCT]: true,
+      [Modules.PRICING]: true,
+    },
     sharedResourcesConfig: {
       database: { clientUrl: process.env.POSTGRES_URL },
     },
   })
 
+  // Set the filters for the query
   const filters = {
     take: parseInt(params.limit) || 100,
     skip: parseInt(params.offset) || 0,
@@ -90,6 +103,7 @@ async function getProductsByCollectionId(
     currency_code,
   }
 
+  // Set the GraphQL query
   const productsQuery = `#graphql
     query($filters: Record, $take: Int, $skip: Int) {
       products(filters: $filters, take: $take, skip: $skip) {
@@ -137,33 +151,19 @@ async function getProductsByCollectionId(
       }
     }`
 
+  // Run the query
   const { rows, metadata } = await query(productsQuery, filters)
 
-  for (const product of rows) {
-    for (const variant of product.variants) {
-      const priceSetIds = variant.price.map((price) => price.price_set.id)
-
-      const prices = await modules.pricingService.calculatePrices(
-        { id: priceSetIds },
-        {
-          context: { currency_code },
-        }
-      )
-
-      const price = prices.find(
-        (price) => price.currency_code === currency_code
-      )
-
-      if (!price) continue
-
-      delete variant.price
-      variant.price = price
-      variant.calculated_price = price.amount
-    }
-  }
+  // Calculate prices
+  const productsWithPrices = await getPricesByPriceSetId({
+    products: rows,
+    currency_code,
+    pricingService: modules.pricingService as unknown as IPricingModuleService,
+  })
 
+  // Return the response
   return {
-    rows,
+    rows: productsWithPrices,
     metadata,
   }
 }

src/app/api/products/route.ts

@@ -2,6 +2,8 @@ import { NextRequest, NextResponse } from "next/server"
 import { notFound } from "next/navigation"
 
 import { MedusaApp, Modules } from "@medusajs/modules-sdk"
+import { getPricesByPriceSetId } from "@lib/util/get-prices-by-price-set-id"
+import { IPricingModuleService } from "@medusajs/types"
 
 /**
  * This endpoint uses the serverless Product and Pricing Modules to retrieve a product list.
@@ -28,27 +30,15 @@ async function getProducts(params: Record<string, any>) {
   limit = limit && parseInt(limit)
   currency_code = currency_code && currency_code.toUpperCase()
 
-  // configure the modules for Remote Query
-  const modulesConfig = [
-    {
-      module: Modules.PRODUCT,
-      path: "@medusajs/product",
-    },
-    {
-      module: Modules.PRICING,
-      path: "@medusajs/pricing",
-    },
-  ]
-
-  // configure the shared resources for Remote Query
-  const sharedResourcesConfig = {
-    database: { clientUrl: process.env.POSTGRES_URL },
-  }
-
   // Initialize Remote Query with the Product and Pricing Modules
   const { query, modules } = await MedusaApp({
-    modulesConfig,
-    sharedResourcesConfig,
+    modulesConfig: {
+      [Modules.PRODUCT]: true,
+      [Modules.PRICING]: true,
+    },
+    sharedResourcesConfig: {
+      database: { clientUrl: process.env.POSTGRES_URL },
+    },
   })
 
   // Set the filters for the query
@@ -112,35 +102,19 @@ async function getProducts(params: Record<string, any>) {
     metadata: { count },
   } = await query(productsQuery, filters)
 
-  for (const product of products) {
-    for (const variant of product.variants) {
-      const priceSetIds = variant.price.map((price) => price.price_set.id)
-
-      const prices = await modules.pricingService.calculatePrices(
-        { id: priceSetIds },
-        {
-          context: { currency_code },
-        }
-      )
-
-      const price = prices.find(
-        (price) => price.currency_code === currency_code
-      )
-
-      if (!price) continue
-
-      delete variant.price
-      variant.price = price
-      variant.calculated_price = price.amount
-    }
-  }
+  // Calculate prices
+  const productsWithPrices = await getPricesByPriceSetId({
+    products,
+    currency_code,
+    pricingService: modules.pricingService as unknown as IPricingModuleService,
+  })
 
   // Calculate the next page
   const nextPage = offset + limit
 
   // Return the response
   return {
-    products,
+    products: productsWithPrices,
     count: count,
     nextPage: count > nextPage ? nextPage : null,
   }