Today’s businesses, especially ecommerce, are focused on innovation, flexibility, speed, and scalability. These needs are making businesses turn to modern headless commerce architecture to power their ecommerce experiences. A composable approach makes your applications more efficient and reliable.

In traditional ecommerce platforms, the frontend and backend are tied together and as such lack flexibility. When you want to customize a feature, you have to ensure you don’t break some other feature. Most of the time, you cannot add or alter any feature without affecting others.

In composable commerce, however, you can extend the features without disturbing or altering existing components. Additionally, composable commerce components can adapt to different environments easily.

Composable commerce platforms are flexible: the frontend and backend are not tied together; they are loosely packed. In short, you can say composable commerce applications are more service-oriented.

This article explains what composable ecommerce is and its features. It also highlights some of the leading composable commerce platforms.

## What is a Composable Ecommerce Platform?

[Composable commerce](https://medusajs.com/blog/composable-commerce/) is a strategy that lets you select best-of-breed ecommerce components and merge them into a custom application.

Composable commerce uses MACH (Microservices architecture, APIs, Cloud, and Headless). In addition, developers can use other technology stacks like Jamstack (JavaScript, APIs, and Markup) and other modern technologies.

Composable commerce as a software architecture or platform separates the frontend (UI) from the backend (business logic).

It also allows you to build a flexible ecommerce stack by selecting best-of-breed components/technologies.
Let’s take an example of a composable commerce shop. Here, this shop might use various solutions or platforms to address different issues—shipping, adding content/products to the website, processing payments, and so on.

![](/images/WO1-BS24y-.png)

Let’s take an example of a composable commerce shop. Here, this shop might use various solutions or platforms to address different issues—shipping, adding content/products to the website, processing payments, and so on.

These solutions might come from different vendors or may be even pre-built, but for customers, it is a single ecommerce store. In other words, you can “compose” several components into a custom application that performs specific business functions. When you make changes or fix issues in one solution, it will not affect others.

In a similar way, when you want to add a feature or a component, you need not upgrade your entire application. You can always choose the best-in-breed solutions for different components and functionalities and still your application function as a unified solution.

## Why Do We Need Composable Commerce?

Composable commerce is the future of ecommerce industry; with its robustness and distributed approach, it is fast becoming a powerful tool in ecommerce industry. Below are some of the reasons composable commerce is important:

*   Composable commerce is built by taking speed and flexibility into consideration. This approach is committed to keeping up with the customers’ demands and giving them engaging experiences.
*   The composable commerce approach does not rely on only one vendor for all the functionality. Instead, it utilizes various vendors and thus offers robust, comprehensive functionality to its customers.
*   Since composable commerce “composes” various components, the breaking of one component does not necessarily mean other components will fail.

## What is PBC?

In composable commerce platforms, PBC stands for “Packaged Business Capabilities”. You can simply envision PBCs as building blocks for your ecommerce store.

Each of these PBCs is a standalone solution or a part of a larger platform. Each PBC comes with a separate service that can communicate with other components. This communication between components is done through APIs. PBCs follow api first approach and major communication between software components is done through APIs.

Each PBC in a composable commerce platform is a feature of the application and can be a third-party component. So, in an application, a shopping cart or a promotion is a PBC.

## Benefits of Composable Commerce Platforms

Composable commerce platforms as mentioned earlier are beneficial in different ways, as they are generally seamless and easy to use or navigate. In this section, we’ll further discuss the benefits of composable commerce platforms.

### Customization

Using composable ecommerce platforms, you can personalize and build your own applications instead of just using what’s created for you. The composable ecommerce applications are tailored to your needs.

For instance, if you want only basic features for your application like ordering, cart management and payment process, you can very well build this basic application by composing the required features.

Similarly, if you want an advanced application, you can build an advanced application. So you can build your own applications as per your business requirements.

### Scalability

Composable commerce applications are scalable; you can easily add more features to your existing application. They grow with your growing needs. For example, you can add AR (Augmented Reality) feature to your application for customers to actually feel the products.

### Independent Development

Using composable commerce architecture, development processes are less complicated. Changes in one component will not lead to the failure of other components. The upgrade is no longer a nightmare for developers. The programming process is much faster and safer. Each development team can work independently without any interference from other teams.

### Agility and Flexibility

Nowadays, applications are sold across various channels like the web, mobile, social media, etc. This requires that the applications should be flexible and easily extensible.

The composable commerce approach provides this flexibility and extensibility to applications. You can use your application on various platforms like web, mobile etc. There is a minimal chance of your application not working on different platforms.

### Future-Proof Approach

A business using a composable commerce approach is always ready for the future. You can migrate your applications to a composable commerce platform with only high-priority features migrated first. For example, with the advancement in technology, more and more powerful technology, platforms become available every day.

A composable commerce approach allows you to easily switch to more advanced solutions/components without much of a hassle. You don’t need to upgrade your entire system just to include one feature.

## Composable Commerce vs Headless Commerce

By now, you have got a basic idea of what composable commerce is. How does composable commerce differ from [headless commerce](https://medusajs.com/blog/headless-architecture/)?

A headless commerce solution, a component of composable commerce, is the decoupling of the frontend layer from the backend layer. Composable commerce leverages all aspects of MACH architecture and also uses a modular approach, open ecosystem, and business-centric solutions.

Composable commerce is a step ahead of headless commerce. For many applications, headless commerce is the first step towards a flexible architecture that is composable commerce. Composable commerce adapts the flexibility of headless commerce solutions to the next level.

Composable commerce and headless commerce are two different architectures, but headless commerce is the first step you can take towards a more reliable, modular composable commerce platform.

Going forward let’s evaluate two of the popular ecommerce platforms that use a composable commerce approach, Commercetools, and [Medusa](https://docs.medusajs.com/introduction#features). First, let’s discuss Commercetools and then Medusa.

## Commercetools: A Leading Proprietary Ecommerce Platform

Commercetools is a leading proprietary ecommerce platform. Using Commercetools, you can create a visually appealing, highly-functional customer experience.

Commercetools is a modern language-neutral platform with powerful commerce functionality and features. The platform is extensible, future-ready, and improves productivity.

Commercetools platform uses a multi-cloud infrastructure. It supports three main cloud vendors namely, AWS, GCP, and Azure. Commercetools is a modern commerce platform that runs multi-tenant architecture, bringing multiple benefits to you, including time and cost savings.

### Features of Commercetools

*   Extensible Platform API: Commercetools offers well-documented APIs that are easily extensible. These APIs help you to develop powerful applications and good customer experience.
*   Efficient Product Catalog and Order Management: Using Commercetools, you can create and organize the product catalog to simplify your customer experience as well as your business. You are also able to define the cart with the collected information.
*   Central Data Management Centre: Commercetool has a central data management location called *Merchant Center* to manage data, product information, catalogs, etc. It acts as a command base for Commercetools APIs and Microservices.

## Medusa: The Most Popular JavaScript Open Source Ecommerce Platform

[Medusa](https://github.com/medusajs/medusa) is an open source headless commerce engine built with Node.js. With Medusa, developers can build scalable, sophisticated commerce setups with minimal effort and great developer experience.

[Medusa](https://medusajs.com/blog/nodejs-ecommerce-backend/) provides you with a full commerce engine with APIs to manage products, carts, customers, orders, payments, etc... The backend and frontend in Medusa are decoupled and as such, they are free from restrictions imposed by one another. They are both lighter and faster.

The Medusa backend is built on Node.js and Express. For easier development, Medusa allows using SQLite for the database, but it is highly recommended to use PostgreSQL for production or advanced development.

Medusa also uses Redis as an event management queue. Certain actions trigger events in Medusa. Developers can use Subscribers to listen to these events and perform a subsequent action when the events are triggered.

For example, when an order is placed, the `order.placed` event is dispatched. Subscribers listening to that event then are executed. You can listen to the `order.placed` event to sent a confirmation email, for example.

## Medusa Architecture Overview

Medusa is split into three core components:

![](/images/xFysWyOZ83.png)

1.  Medusa Server: It holds all the logic and data processing of your ecommerce platform. It connects to the database and the event queue system. The Medusa server is a headless server, meaning that frontend interfaces such as the storefront and admin are not directly coupled with it. The server exposes [REST APIs ](https://docs.medusajs.com/api/store/)that can be used to implement the storefront and admin, as well as other integrations.
2.  Storefront: This is the frontend for your store that customers use to browse products and make purchases. Medusa offers two storefront starters: one built using [Next.js](https://docs.medusajs.com/starters/nextjs-medusa-starter/) and another using [Gatsby](https://docs.medusajs.com/starters/gatsby-medusa-starter/). You can also build your own storefront using the [REST APIs](https://docs.medusajs.com/api/store). You can build the storefront with the framework of your choice, such as [Vue.js](https://medusajs.com/blog/vue-js-ecommerce-create-your-ecommerce-store-with-medusa/) or [React Native](https://medusajs.com/blog/creating-react-native-ecommerce-app-with-medusa/).
3.  Medusa Admin: The admin is used by merchants to manage their store’s data such as manage their products or orders. Medusa provides an intuitive admin with advanced functionality and seamless experience. You can also build your own admin dashboard using the [REST APIs](https://docs.medusajs.com/api/admin).

## Unique Features of Medusa

![](/images/KVofHYFy42.png)

Some of the unique features of Medusa are discussed below.

*   Open Source & Composable: Medusa is an open source composable commerce platform. Aside from the customizability and extensibility that comes with composable platforms, its open source nature gives developers full freedom to re-shape the platform as needed or use it as-is.
*   Customizable core: Developers can create their own endpoints, services, subscribers, entities, and more in Medusa’s core. Medusa ensures to load both defined functionalities in its core, as well as customization developers add. Developers can also create plugins and distribute their customization as reusable packages.
*   Orders, Exchanges, and Returns: Medusa provides you with an easy and automated way to manage returns, claims, and swaps. This is in addition to the standard order management process offered by ecommerce platforms.
*   Product and Customer Management: Medusa allows you to add products with extensive customization and sort them into collections. Similarly,  you can manage customers and assigns them to customer groups.
*   Integration with third-party services: Medusa can be integrated to the best-in-breed solutions such as payment providers, search engines, or notification providers. For example, you can integrate Medusa with CMS platforms like [Strapi](https://docs.strapi.io/developer-docs/latest/getting-started/quick-start.html#\_1-install-strapi-and-create-a-new-project) to build an ecommerce store with a fast, content-rich frontend and a highly extensible backend.
*   Pricelist, Discounts and Tax Management: With Medusa, you can add discounts or perform price overrides based on different conditions such as the total amount of the cart or availability of specific items in the cart. Tax-related configurations are also available per region and you can specify different rates for specific products.
*   Sales Channels Management: Sales channels are used to define the availability of products in different channels. For example, you can specify products available for B2C customers and others for B2B customers. In Medusa you can add unlimited amount of sales channels. Orders can also be associated with a specific sales channel.

# **Conclusion**

This article discussed composable commerce platforms. As the name suggests you can "Compose" the components and create our own applications as per your needs. Composable commerce platform is the future of ecommerce applications.

[Medusa ](https://docs.medusajs.com/)is a platform that uses Composable Commerce architecture. It provides advanced ecommerce features, and offers developers and businesses flexibility in choosing and building their tech stack. This guarantees that when using Medusa you’re in full control of your platform, providing high scalability and flexibility.

You can get started with Medusa by following the [quickstart guide](https://docs.medusajs.com/usage/create-medusa-app).

> For any issues or questions related to this article, feel free to reach out to the Medusa team via [Discord](https://discord.gg/F87eGuwkTp).


Composable Ecommerce platform explained

Find related blog posts below

Want to know more about Medusa

Inspired by Git: How we Designed our Order-Editing Feature

[Medusa’s](https://github.com/medusajs/medusa) Order API supports order editing capabilities that equip merchants and developers with the tooling necessary to reduce manual work and offer a great customer experience.

Designing this seemingly simple functionality proved to be a complex task that was solved with inspiration from the world's most-used developer tools.

This article covers how we adopted principles from the Git version control system and GitHub in our Order Editing API design. You can read the product announcement [here](https://medusajs.com/blog/order-edits-announcement/).

## Understanding Order Editing

Before going over the design behind this feature, we need to understand its constraints. Let’s dive into what it means to edit an order in Medusa.

When an order is placed, it is in its base state from a customer and store administrator point of view. Generally, the next steps for orders from here are fulfillment, shipping, and payment capturing.

Sometimes a change in the order might be required first. Several scenarios could lead to this; the customer changed their mind about their purchase, the inventory management system was out of sync with the physical stock, or the merchant wants to add a complimentary item due to long processing time.

A naive solution would allow store administrators to modify order items directly. However, this could have serious consequences. Order history is lost or becomes misleading, potential unresolved payment discrepancies arise, and stale order data remain in integrated services, such as analytics providers.

Aside from ensuring data consistency in your underlying dependencies, you also want to offer a good customer experience. Instead of changing things directly, you want to give customers full control and confidence by allowing them to confirm a change before it is completed. Supporting these cases spawns the need to introduce an intermediate pending step for the edits you make to an order.

It should be clear that editing an order is not as straightforward as updating the quantity of a line item. There are many use cases and dependencies to consider to ensure data is consistent across all systems in your stack and that customers get the best experience.

## Building an API with git-like flow of events

As we started to plan the feature, it became apparent that we were building a subset of the functionality from a version control system with a pull request-like mechanism for editing an order.

The goal was to allow users to change the original state of their order with an approval-staged flow without losing its history. A Git-like system with the management capabilities offered by GitHub.

We were excited to realize that a developer-centric pattern from our daily work could directly apply to our API design.

We can see the following resemblance between the order-editing flow and a git-like system:

*   Order placed → Main branch
*   Store administrator initiates an order edit → Branches out from main
*   Store administrator makes changes to order edit → Pushes commits to branch
*   Store administrator submits an order edit → Opens a pull request to main
*   Customer confirms an order edit → Reviewer approves the pull request

We even extended the capabilities of the API with additional functionality as a result of using the Git + GitHub analogy:

*   Store administrator force completes an order edit → Core maintainer force merges a pull request
*   Customer requests an additional item → Reviewer requests changes to the pull request

Our feature had a functional requirement of having an intermediate step between initializing the edit and committing the changes. In this state, you can create multiple edits to the order without applying them. This is similar to pushing commits to a branch while a feature is in work-in-progress, except we only allow one commit for each order edit. More on that later.

### Design

Now let’s turn to implementation specifics to see how the analogy took shape in our data layer.

There are two database models worth highlighting: `OrderEdit` and `OrderItemChange`:

```
// order-edit.ts

OrderEdit
- id
- order
- changes
- internal_note
- items

// order-item-change.ts

OrderItemChange
- id
- original_line_item
- line_item
- type (add, remove, update)
```

Only properties relevant to the Git analogy are included above. If you wish to explore the models more in-depth, you can find them [here](https://docs.medusajs.com/references/entities/classes/OrderEdit).

The `OrderEdit` model holds the modifications you want to make to your order. It references the original order, stores an internal note, and contains a list of edits. When an `OrderEdit` is created, all items from the Order are copied to the `OrderEdit`.

The edits are represented as one or more `OrderItemChange` records. There are three types of changes: Add, Remove and Update. The purpose of each should be clear. When an edit is created, we store a copy of the original item to ensure full visibility of the history when these changes are eventually applied.

You might have already drawn the parallels to Git. The above data modeling is comparable to how branches, staged changes, and commits work. The `OrderEdit` is your branch diverging from the main one, and the `OrderItemChange` records are your staged changes ready to be pushed.

Together, they constitute the commit with a message and hold the information capable of showing a diff of the changes.

### Limitations to the analogy

Not all aspects of a traditional version control system apply to our feature. Whereas Git is excellent at facilitating seamless collaboration among an indefinite number of users, our feature is limited to one active order edit at a time. Only one branch aside from the main one.

This is to guard businesses against unwanted situations arising from multiple ongoing edits and outbound payment links. An example would be that customers accidentally pay for the wrong order edit. We built the logic to eliminate potential merge conflicts.

And finally, we don’t offer a way for merchants to roll back the changes when first committed. The changes made to an Order are irreversible. No `git revert`.

## Demo

Enough talking. Let’s see it in action.

<video width="700" height="504" controls preload="none" style="margin: 0 auto; object-fit: cover;" poster="/images/order-editing-poster.png">
<source src="/videos/order-editing.mp4" type="video/mp4" />
</video>

## Conclusion

Designing our Order Editing API was especially exciting, as it allowed us to apply existing concepts from our daily work to solve a problem for our users. The API we built provides a great developer experience by using familiar concepts while abstracting away the complexity for our merchants in the admin system.

For concrete API examples of the full order editing flow, see our how-to documentations on:

*   [Edit an order as an administrator](https://docs.medusajs.com/references/entities/classes/OrderEdit)
*   [Implement order-editing on the storefront](https://docs.medusajs.com/advanced/storefront/handle-order-edits)



Order Edits and Payment Collections are now available

[Medusa](https://github.com/medusajs/medusa) is happy to announce Order Editing and Payment Collections as the latest additions to the Order API, strengthening one of the most critical parts of any commerce application. This is an essential step in our mission to deliver commerce building blocks that developers can use to create bespoke digital commerce experiences without reinventing core commerce functionality.

The Order Editing and Payment Collection features solve the problems faced when businesses need to change already placed orders. Systems that rely on order data, like fulfillment and accounting systems, will have to be updated, and payment discrepancies may arise. These updates and discrepancies often require error-prone, manual work.

Medusa’s new capabilities offer a simple and worry-free approach to creating order edits while giving your customers the best experience.

## How Order Editing Works

The Order Edit flow consists of three simple steps:

1.  Select the changes you wish to make.
2.  Ask the customer to confirm your changes or, as an admin, force a confirmation.
3.  See the order edit merged into the order and continue managing your order as usual.

<video width="700" height="504" controls preload="none" style="margin: 0 auto; object-fit: cover;" poster="/images/order-editing-poster.png">
<source src="/videos/order-editing.mp4" type="video/mp4" />
</video>

Editing orders in Medusa allows you to update, add and remove line items on already placed orders with a few easy steps.

Helpful timeline events ensure that you and your team have visibility to understand the order’s history and assist customers with questions about their orders.

To learn more about how we designed Medusa’s order editing capabilities, check out [this article that dives deeper into the solution](/blog/git-inspired-order-editing-feature/).

### Give your customers confidence and peace of mind

The confirmation step is essential to the order editing flow and ensures that your customer is always in the loop about changes to their order. You can configure notifications that automatically inform customers that they must accept changes to their orders.

They can confirm their changes with simple steps and pay for potential shipping and total differences.

<video width="700" height="504" controls preload="none" style="margin: 0 auto; object-fit: cover;" poster="/images/payment-collection-poster.png">
<source src="/videos/payment-collection.mp4" type="video/mp4" />
</video>

Customers can accept order edits to stay in the loop about changes to their order and pay for potential differences.

For businesses, Medusa’s extensible API also provides a new opportunity to upsell customers and highlight products.

## New possibilities with great APIs

Everything we build at Medusa is deliberately designed to give a robust starting point while remaining open for customizations and extensions that can make Medusa truly your own. This is also the case for Order Editing and Payment Collections, where plugins and projects can now listen to a comprehensive set of new events that can act as triggers for automations and integrations.

Accounting and fulfillment plugins, for example, will be able to listen for changes to orders and update systems to ensure consistency throughout your stack. This eliminates manual work while giving your customers a fast and smooth experience.

```
// src/subscribers/my-subscriber.ts

eventBus.subscribe(OrderEditService.REQUESTED, async ({ id }) => {
  const analyticsData = await getTrackingData(id)
  analyticsProvider.track("Order Edit Requested", analyticsData)
})
```

Finally, our Payment Collection API will soon expand to support broader use cases like re-authorizing expired payment authorizations and creating new payment experiences for your customers, like installments or deposit payments.

## Try it out now

We are excited to see what unique new experiences and plugins will be built with the new Order Editing and Payment Collection capabilities.

Try it out now by upgrading to the latest version of Medusa:

```
yarn add @medusajs/medusa@latest
```

Or start a new project:

```
yarn create medusa-app
```

If you’re interested in learning more about this feature, check out [this article](/blog/git-inspired-order-editing-feature/) which goes over how Git and GitHub inspired the design of the Order Editing capabilities.

You can also learn more about order editing in our documentation:

*   [How to implement order editing functionalities for administrators](https://docs.medusajs.com/advanced/admin/order-edit)
*   [How to implement order editing functionalities in a storefront](https://docs.medusajs.com/advanced/storefront/handle-order-edits)
*   OrderEdit [Admin](https://docs.medusajs.com/api/admin/#tag/OrderEdit) and [Store](https://docs.medusajs.com/api/store/#tag/OrderEdit) API reference



Ecommerce APIs: What they are and how they work

Ecommerce APIs are a means of interaction between an ecommerce platform and various backend systems. This interaction is needed in order to transfer information between software and use the data to fulfil ecommerce functionalities. Some of these ecommerce functionalities include Payment API, Login API, Customer API, Order API, Sales Tax API, and more.

Ecommerce APIs have changed and improved how ecommerce sites interact with each other. They have provided an avenue for seamless interaction and syncing of ecommerce functionalities to achieve business goals and provide effective solutions.

This article first discusses the basics of ecommerce APIs and an in-depth evaluation of an open source ecommerce API-first solution —[Medusa](https://medusajs.com/).

## What is an Ecommerce API?

Google defines APIs as a set of functions and procedures allowing the creation of applications that access the features or data of an operating system, application, or other services.

Generally, an API defines how two pieces of software should communicate.

APIs work by connecting the platform with the backend to fetch data to be displayed on the ecommerce user interface. Different API architectures can be used but REST API has become widely adopted for building APIs. It makes use of HTTP requests to access the information from the server.

Going by the definition above, an ecommerce API is a service that integrates different components of an ecommerce store into a system that implements ecommerce functionalities. Some of these functionalities could include payments, shipping, order placement, location, and mapping.

![](/images/D0B73A74-15A1-4840-9DB2-FEBE357CA9C6\_1\_201\_a.jpeg)

## Benefits of Ecommerce APIs

Ecommerce APIs have many benefits including:

*   Ecommerce APIs enable the transfer of information between one software and another and converge all the data on the frontend for users to interact with.
*   APIs make use of various third-party services and tools that provide advanced features like [analytics](https://medusajs.com/blog/medusa-matomo-next-js/), monitoring traffic and errors, etc. This gives ecommerce businesses access to these software functionalities without the need to reinvent the wheel.
*   Ecommerce APIs also add the micro-service functionalities needed by ecommerce stores to ensure ease of use for customers. Some of these micro-services include inventory, order, product, and payment.

## Ecommerce API Examples

There are many ecommerce APIs that are essential for building an ecommerce platform.

Integrating these systems properly into your ecommerce platform makes it dynamic and ultimately improves its efficiency. These functionalities could serve as the edge needed to attract and retain customers in a competitive ecommerce market.

### Customer APIs

A *Customer API* allows you to validate a user as the true account owner before granting them access to their ecommerce website account. The *Customer API* enables you to manage [customer profiles](https://medusajs.com/blog/next.js-ecommerce-store) and registration, as well as other profile functionalities.

### Cart APIs

*Cart APIs* allow customers to choose items they want to purchase in an ecommerce store. It compiles tasks such as calculating prices of ordered items, applying discounts, and including taxes. While doing so, customers can also apply coupon codes or discount vouchers if any.

### Product APIs

A *Product API* lets users view and verify product details from the product record. This provides users with all the basic information they might need, including product description, product image, product spec, product cost, and others.

### Payment APIs

A *Payment API* creates payment processes such as a secure payment system, accepting different payment options, and integrating payment gateways such as [Stripe payment gateways](https://medusajs.com/blog/nextjs-ecommerce-storefront-comes-packed-with-ready-integrations-to-paypal-meilisearch-stripe-and-more/).

### Shipping APIs

*Shipping APIs* are responsible for handling all the processes required to fulfil and deliver customers’ orders. *Shipping APIs* help ecommerce businesses to ship, track details, and fulfil customers’ orders directly from their ecommerce websites.

A shipping API can also give you the option of integrating different shipment services, such as DHL or USPS, for the best shipping experience for customers.

### Order APIs

The *Order API* makes it possible for customers to place their orders. It is also responsible for management functionalities like cancelling an order, collecting necessary information needed for delivering orders, and generally sorting order information.

## Medusa: An Open Source Ecommerce API Solution

[Medusa](https://github.com/medusajs/medusa) is an open source, headless, ecommerce platform. It is a composable commerce platform built with Node.js to provide developers with a great experience in building an ecommerce solution without any hassle.

The server is headless; this means that the frontend is made separate from the backend to allow customizations on one end and interactions on the other. It makes it more viable for ecommerce owners who want to have control over their ecommerce ecosystem.

Developers with knowledge of JavaScript or TypeScript can work their way around Medusa as it is beginner-friendly and easy to start with.

### Medusa’s Architecture

Medusa is made up of three components that provide developers with all the parts needed to build a fully-functional ecommerce store. You can either use all components or just the parts needed for your ecommerce and integrate them with other software. This makes Medusa a flexible platform.

These three components are:

![](/images/ZHvM2bu_td4rnx_$1$.png)

1.  The Medusa Server: The backend is the core of the ecommerce store and the most integral part of the ecommerce platform for developers. Medusa makes it beginner-friendly for developers to build on the platform using API integration.

2.  The Storefront: This is the interface that ecommerce customers get to see and interact with. Medusa provides two storefronts built using [Next.js](https://github.com/vercel/next.js) and [Gatsby](https://github.com/gatsbyjs/gatsby). These frameworks generate a static website that connects to the headless server and makes the website fast. You can also build your storefront using the [storefront API](https://docs.medusajs.com/api/store/) that the platform provides.

3.  The Medusa Admin: The [Medusa Admin](https://github.com/medusajs/admin) was created to help ecommerce store owners manage their businesses. They can manage their products, orders, customer interaction with the store, and other features using the admin panel. Medusa allows you to use the existing admin panel or build yours using the [admin APIs](https://docs.medusajs.com/api/admin/).

## How Medusa is an API-First Solution Built for Developers

In most cases, software companies build their platform and then add APIs as an add-on. An API-first solution approach means that the API is the core product and it ensures that all functionalities in the platform are obtainable to consumers through their APIs.

This solution gives consumers the luxury of scalability, flexibility, and performance. It is useful for automation or integration and allows you to access all of the functionalities of the platform.

[Medusa](https://medusajs.com/) was built from scratch as an API-first ecommerce solution that is to be consumed using its APIs. It offers two out-of-the-box APIs. The first API is for [administration](https://docs.medusajs.com/api/admin/), while the second is for the [storefront](https://docs.medusajs.com/api/store/). It gives enterprises first-hand access to the core capabilities of the platform and allows you to customize per your business’s need.

An API-first solution mandates you to think about how developers will communicate with your API. You need to ensure their knowledge of its functionality and how they can easily interact with it. Subsequent maintenance and security standards should also be considered. The tools used to develop the API also have to be accounted for to make it compatible for easy integration.

## Why Medusa is the #1 Choice for Developers

Certain features and functionalities make [Medusa](https://github.com/medusajs/medusa) more desirable and developers’ first choice.

As Medusa is an open source solution, it can be customized to fit the business requirements. You can either use the platform as is, or pick it apart to implement the flows or features specific to your use case.

Developers can also utilize Medusa’s flexible architecture to implement custom functionalities through [custom plugins](https://docs.medusajs.com/advanced/backend/plugins/create). They can be used to customize the shopping experience to their business needs or integrate Medusa with other services, among other usages.

Medusa is an API-first solution platform with flexible customization for developers. The Medusa platform is a way out of the traditional eCommerce API, which provides developers with a platform to customize their ecommerce platforms while maintaining maximum performance and efficient service.

In addition, Medusa has an active community on [Discord](https://discord.gg/medusajs) and [GitHub](https://github.com/medusajs/medusa/discussions). Developers can reach out to others for help if any issue arises. They can also report issues directly to the core Medusa team if necessary.

## Ecommerce APIs Available in Medusa

The APIs highlighted as ecommerce API examples are some of the APIs available with Medusa. Some of the other ones also offered are explained below.

### Sales Channel API

The *Sales Channel API* allows merchants to sell their items between multiple channels while having control over the products and orders in each channel. You also have the liberty of marketing each [sales channel](https://medusajs.com/blog/medusa-v-1-7-3/) separately across the different platforms your business uses.

![https://res.cloudinary.com/practicaldev/image/fetch/s--J5ZnsMfR--/c_limit%2Cf_auto%2Cfl_progressive%2Cq\_66%2Cw\_880/https://dev-to-uploads.s3.amazonaws.com/uploads/articles/yc7sp37on1776bqzeuaf.gif](https://res.cloudinary.com/practicaldev/image/fetch/s--J5ZnsMfR--/c_limit%2Cf_auto%2Cfl_progressive%2Cq\_66%2Cw\_880/https://dev-to-uploads.s3.amazonaws.com/uploads/articles/yc7sp37on1776bqzeuaf.gif)

Business owners can create as many sales channels as necessary. They can indicate the available products when organizing the sales channel.

Medusa Admin allows you to filter orders by each sales channel. This way, the merchants can view all orders in one place as well as view orders from each specific sales channel.

### Pricelist API

The *Pricelist API* was created to provide merchants with even more customization and extendibility options by allowing them to have more control over their pricing of products.

Asides from the default price selection strategy available, the [pricelist API](https://docs.medusajs.com/advanced/backend/price-selection-strategy/override) also provides merchants with the flexibility to customize and override product prices for specific customer groups, regions, general conditions, or discount prices for bulk orders.

![https://res.cloudinary.com/practicaldev/image/fetch/s--XpDXou0r--/c_limit%2Cf_auto%2Cfl_progressive%2Cq\_66%2Cw\_880/https://dev-to-uploads.s3.amazonaws.com/uploads/articles/55kr705vo4bu32s8zg6f.gif](https://res.cloudinary.com/practicaldev/image/fetch/s--XpDXou0r--/c_limit%2Cf_auto%2Cfl_progressive%2Cq\_66%2Cw\_880/https://dev-to-uploads.s3.amazonaws.com/uploads/articles/55kr705vo4bu32s8zg6f.gif)

### Bulk Imports and Exports API

This API allows for bulk imports and exports of products into your ecommerce store on Medusa. You can also import other entities such as prices in a price list. This makes the process of migrating from other platforms to Medusa easier.

Developers can also [customize](https://docs.medusajs.com/advanced/backend/batch-jobs/customize-import) existing import and export strategies in case they want to change the accepted column to eliminate the need to make changes to their CSV files. In addition, they can create their own strategy to import or export any entity such as customers or sales channels.

![](/images/9F3F0915-C896-496C-9DF5-44D7097678C7.png)

### Tax APIs

Taxes in Medusa are associated with a specific region. A product can have the same price across different regions but a different [tax rate](https://docs.medusajs.com/user-guide/taxes/tax-rates) is applied in each region.

Medusa handles the calculation of the applied tax rate in the backend. Medusa provides a default tax provider, but developers can implement a tax provider of their own to handle different tax calculations for different regions.

![](/images/B839D99D-8993-466B-984B-6384E10794BB\_1\_201\_a.jpeg)

Furthermore, merchants can enable [tax-inclusive pricing](https://docs.medusajs.com/user-guide/taxes/tax-inclusive) for regions, currencies, or price lists. This allows merchants to set a specific price for products or shipping options without having to manually calculate what taxes need to be implemented for different regions. Medusa handles the calculation of the taxes automatically during the checkout process.

### Conclusion

This article discussed ecommerce APIs as a solution for developers to build composable and flexible ecommerce platforms. It provides a lot of benefits for both developers and businesses such as integrations with best-in-breed solutions and the ability to implement custom and advanced use cases within the platform.

Medusa is a composable commerce platform that uses ecommerce APIs by design. You can use Medusa’s existing APIs that provide features related to products, carts, orders, and more. You can also create custom APIs specific to your business use case.

Check out the Medusa [documentation](https://docs.medusajs.com) to learn how to get started.

> Should you have any issues or questions related to Medusa, then feel free to reach out to the Medusa team via [Discord](https://discord.gg/F87eGuwkTp).



Multi-currency Ecommerce: How to Take Multiple Currencies in Your Storefront

## Introduction

Multi-currency ecommerce is an avenue for business owners or merchants to sell their products without barriers, allowing buyers to make purchases in their own currency.

This feature has many benefits; it makes buying and selling seamless as customers can know the exact cost of products without having to deal with multiple calculations or pay conversion fees.

[Medusa](https://github.com/medusajs/medusa), alongside its numerous benefits, supports the implementation of multi-currency for stores. Merchants can add an unlimited number of currencies and regions to their store, and specify prices specific for each currency and region.

In this article, you’ll learn more about the benefits of multi-currency support. You’ll also learn about what Medusa is and how to use its multi-currency feature.

## What is Medusa?

[Medusa](https://medusajs.com/) is an open source composable commerce platform that enables individuals and businesses to build unique digital experiences in their online stores. It offers limitless customization capabilities for developers to cater the ecommerce store to the business use case.

> Suggested Read: [Explained in 5 Levels of Difficulty: Ecommerce by Medusa](https://medusajs.com/blog/explained-5-levels-of-difficulty-ecommerce-by-medusa/)

Medusa comes with pre-built ecommerce rich features such as multiple payment methods for credit cards, shopping carts, and multiple currencies for the global market.

Medusa's ecommerce engine also provides multi-currency and regions support. Medusa offers a feature that is [missing in many ecommerce platforms](https://medusajs.com/blog/shopify-multi-currency-issue/). Instead of forcing a conversion rate on all products, it provides the flexibility of setting prices for each product per currency or region. That makes Medusa stand out from other ecommerce platforms.

## Why is Multi-currency Support Important in Ecommerce?

In an ecommerce platform, the need for multi-currency support is very important and cannot be overlooked.

Some of its benefits include:

*   It allows businesses to sell their products internationally in the local currency of the customer of the online store.
*   It gives businesses more flexibility on how they display the price of the product. Conversion rates can lead to prices that are formatted with many decimal points. Setting a specific price can keep the presentational quality of the price and the product.
*   Multi-currency support allows online ecommerce businesses to have control over prices across different countries.
*   It prevent customers from being charged additional fees due to currency conversion rates when they pay with foreign currencies since they get to choose their native currency while shopping.

## Set up Medusa for Multi-Currency Support

In this section, you’ll learn how to install the Medusa server and Medusa admin to benefit from Medusa’s multi-currency support.

## **Prerequisites**

Before you start this tutorial, ensure you have the following:

*   [Node](https://nodejs.org/en/download/) v14 or a later version.
*   Medusa CLI installed.  Run this command below to install Medusa CLI:

```
npm install @medusajs/medusa-cli -g
```

### Creating a New Medusa Project

Run the command below to create your new medusa store project:

```
medusa new my-medusa-store --seed
```

The above command will create a Medusa store for you in the new directory `my-medusa-store`.

Next, change the directory to your newly created project and start your Medusa server:

```
cd my-medusa-store
medusa develop
```

Medusa store runs on port `9000` by default. You can test your store with this URL on your browse: `localhost:9000/store/products`.

### Creating Medusa Store Admin

Medusa Admin is connected with the Medusa server and many ecommerce features such as product management, order management, customer management, discounts and gift management, pricing, settings, and more.

To create Medusa Admin, start by cloning the Medusa Admin GitHub repository. Use the command below:

```
git clone https://github.com/medusajs/admin medusa-admin
```

After the above command has been completed, change your directory with this command:

```
cd medusa-admin
```

Now, install dependencies and start your admin:

```
npm install
npm run start
```

By default, the admin runs on port `7000`. So, in your browser, go to `localhost:7000` to view your admin. It should look similar to the image below.

![](/images/XYqMCo9\_hq1fsv.png)

Medusa Admin has default admin login details which are “`admin@medusa-test.com`" as the email address password “`supersecret`” as the password. The default admin login information exists because you added `--seed` to the `medusa new` command when you created Medusa Server.

## Using Multi-currency in Medusa

You can add multiple currencies in your ecommerce store from the Medusa admin. You can create multiple regions in the same store and select the currency of the region. Then, you’ll be able to set the price of the product differently for each currency.

### Adding More Currencies

To add more currencies to your ecommerce storefront from Medusa Admin, follow the steps below:

*   Open the Medusa Admin settings page, and click on currencies.

![](/images/med2-6a6689c4.png)

*   Click on *Edit Currencies* to open the the current store currencies dialog.

![](/images/med3-5ef92be0.png)

*   Click on *Add Currencies* to add more currencies to your Medusa store.

![](/images/med4-3f50482d.png)

*   Click the checkbox next to the currencies you want to add.

![](/images/med5.jpg)

After selecting the currencies you need from the above snapshot, click on the “Save and close” button.

### Creating Multiple Regions

Regions are used to manage the countries your ecommerce store operates in. A currency must be associated with a region to be visible and used by customers.

In this section, you’ll learn how to create regions for each of the currencies you created in the previous section.

To create a region, follow the steps below:

1.  Go to *Settings ⇒ Regions.*
2.  Click on the plus button at the top of the *Regions* section.
3.  In the new form that opens:
    1.  For each region, you can select settings specific to that region as indicated in the steps above. You can choose one or more countries to be part of a region. You can also select what currency is provided for that region.
    2.  For example, you can create a region for countries like the USA, Canada, and Australia, and use US Dollar as the currency for that region. You can also create a different region for each of those countries and choose their currencies.
    3.  Note that for a currency to appear in the Currency field, it must be added as explained in the previous section.
4.  After entering all the preferred details of the region, click the “Save and close” button.

![](/images/med7.png)

If you would like to learn more about regions and available features, you can check [*Medusa Regions*](https://docs.medusajs.com/user-guide/regions/manage/) documentation.

### Set Multi-currency Prices for a Product

In this section, you’ll learn how to set a price per currency or region for products.

Follow these steps to set your multi-currency prices while adding your products:

1\.  Select *Variants* on the product general information page.

![](/images/med8-16b0a289.png)

2\.  Click on the *Add an Option* button.

![](/images/med9-acc45848.png)

3\.  After adding a product option, you can create variant by clicking on *Add a variant*.

![](/images/med10.png)

4\.  After clicking on *Add a variant*, you will be prompted to enter general information for the variant. Click on the plus button on the right side of Pricing to set the multi-currency price of the product variant.

![](/images/med11.png)

5\.  You can now set prices for the product per currency and region.

![](/images/med12.jpg)

## Use Multiple Currency in an Ecommerce Storefront

Medusa has some already-built starter storefronts using Next.js and Gatsby.js. For this tutorial, you will be using the [Medusa Next.js Starter storefront](https://medusajs.com/blog/nextjs-ecommerce-storefront-comes-packed-with-ready-integrations-to-paypal-meilisearch-stripe-and-more/).

You can run this command to create your storefront:

```
npx create-next-app -e https://github.com/medusajs/nextjs-starter-medusa my-medusa-storefrontxz
```

`my-medusa-storefront` in the above command represents your storefront name. You can change it to your preferred name.

Next, change to the newly created directory `my-medusa-storefront` and rename the template environment variable file to use environment variables in development:

```
cd my-medusa-storefront
mv .env.template .env.local
```

## Testing Multi-Currency Support

If you completed the above steps, it is time to test if your multi-currency is working perfectly on your storefront. During the testing process, observe how the product prices change based on the selected region.

### Testing your Ecommerce Storefront

Make sure the Medusa server is running, then start the local storefront server:

```
npm run dev
```

Medusa Next.js starter storefront runs on port 8000 by default. You can test your storefront at  `localhost:8000`.

### Test Multi-Currency Support on the Storefront

To test multi-currency support in your store, move down to the footer part of your storefront and click on “Shipping to” to select the list of available countries and currencies that you added to your admin panel.

![](/images/med17.png)

You can then see the products’ prices change based on the selected currency. Try changing to another region and see how the currency and price change.

![](/images/med14.jpg)

### Test Storefront Product API Response

Aside from using the Next.js or Gatsby storefront, you can build your own storefront using Medusa’s APIs. This section explains how to retrieve product prices based on the selected region using Medusa’s APIs.

You can either use the Fetch API to send requests to the Medusa server, or use Medusa’s JS Client.

This tutorial section uses the Medusa JS Client. To install it, run the following command in the directory of your ecommerce storefront:

```
npm install @medusajs/medusa-js
```

Then, you can retrieve the available regions in your Medusa server by sending a request to the List Regions endpoint:

```
import Medusa from "@medusajs/medusa-js"

const medusa = new Medusa()

medusa.regions.list()
.then(({ regions }) => {
  console.log(regions.length)
  // show customers available regions
})
```

You can then display these regions to the customer and allow them to select the region. You can store the selected region in the local storage.

Then, when retrieving the products, pass to the List Products endpoint the `region_id` query parameter with its value being the selected region ID:

```
localhost:9000/store/products?region_id=<region_id>
```

This request returns the products in the store. For each product, you’ll find a `prices` attribute which is an array of prices similar to this:

```
{
   "prices":[
      {
         "id":"ma_01GD0VCDZM2HTAZST8JNTXXPT1",
         "created_at":"2022-09-15T15:13:24.401Z",
         "updated_at":"2022-09-15T15:13:24.401Z",
         "deleted_at":null,
         "currency_code":"eur",
         "amount":0,
         "min_quantity":null,
         "max_quantity":null,
         "price_list_id":null,
         "variant_id":"variant_01GD0VCDY50AA6BX9V3MMNKWN6",
         "region_id":"reg_01GCXWJARKRC5678HB9QTWH1XK",
         "price_list":null
      },
      {
         "id":"ma_01GD0VCDZXSA3C3Z0MY0BCE227",
         "created_at":"2022-09-15T15:13:24.401Z",
         "updated_at":"2022-09-15T15:13:24.401Z",
         "deleted_at":null,
         "currency_code":"eur",
         "amount":2000,
         "min_quantity":null,
         "max_quantity":null,
         "price_list_id":null,
         "variant_id":"variant_01GD0VCDY50AA6BX9V3MMNKWN6",
         "region_id":null,
         "price_list":null
      }
   ]
}
```

Since you provided the ID of the region, the array will include only prices for that region and for the currency of that region.

The array should include at least one price, which is the price set for the currency of the region. The attribute `region_id` for this price will be `null`.

If you’ve set in the admin a price specific for this region, it’ll be added as another entry in the array. This entry has the attribute `region_id` set to the ID of the region.

## Conclusion

Multi-currency support is an important asset for all ecommerce stores. Businesses should keep that in mind while choosing an ecommerce platform for their online store, since not all platforms provide this flexible support.

You can learn more about [Currencies](https://docs.medusajs.com/api/admin/#tag/Currency/operation/GetCurrencies), [Regions](https://docs.medusajs.com/api/store/#tag/Region) and [Region User-Guide](https://docs.medusajs.com/user-guide/regions/manage/) from Medusa documentation.

> If you have any issues or questions or are interested in learning more about Medusa, please join our [Discord](https://discord.gg/medusajs) channel.

[Medusa](https://medusajs.com/)’s multi-currency feature provides the optimal flexibility for businesses as they can set prices for a specific currency and region. Developers can also implement the storefront to show the available regions and prices based on selected region using Medusa’s APIs.


Use ChatGPT to Automate Product Description Writing

In today's fast-paced ecommerce world, it's more important than ever to have compelling product descriptions that clearly and accurately convey the value of your offerings. However, crafting effective descriptions can be time-consuming, especially if you have a large catalog of products. This is where [ChatGPT](https://openai.com/blog/chatgpt/) comes in.

With ChatGPT, you can easily automate the writing of your product descriptions, saving you time and effort while still delivering top-notch content to your customers. What if I told you that the previous paragraph was written by ChatGPT? Did you see how ChatGPT generated human-like text that is indistinguishable?

In this tutorial, you’ll learn how to use ChatGPT to automate writing your product descriptions in [Medusa](https://github.com/medusajs/medusa). Medusa is a [composable ecommerce](https://medusajs.com/blog/composable-commerce/) platform that can be integrated with any third-party services, including ChatGPT.

You can find the code for the tutorial in [this repository](https://github.com/ashutoshkrris/How-to-Use-ChatGPT-to-Automate-Writing-your-Product-Description).

Here’s a demo of the end result.

![](/images/medusa-chatgpt-2462f90e.gif)

## What is Medusa?

[Medusa](https://github.com/medusajs/medusa) is an open source [composable](https://medusajs.com/blog/composable-commerce/) commerce engine for developers who want to take ownership of their ecommerce stack. The platform is highly extensible and easy to customize which has made it the #1 JavaScript Ecommerce Platform on Github in record time with 16K+ stars.

Medusa is composed of three components: the headless backend, the admin dashboard, and the [storefront](https://medusajs.com/blog/next-js-storefront-food-ecommerce-restaurant-medusa-paystack/). You can set up an entire ecommerce store within minutes by running just a couple of commands.

Since Medusa is highly extensible, it allows developers to build custom features or integrate third-party services such as ChatGPT into Medusa very easily. You can learn more about the official and community plugins [here](https://docs.medusajs.com/advanced/backend/plugins/overview/).

## What is ChatGPT?

[OpenAI](https://openai.com/) has developed a revolutionary long-form question-answering AI called ChatGPT; it is capable of answering complex questions conversationally. This technology is groundbreaking because it has been trained to understand the intended meaning behind human questions.

ChatGPT (Generative Pre-trained Transformer) is a powerful AI tool that leverages the capabilities of OpenAI's GPT-3.5 family of large language models. It has been fine-tuned using a combination of supervised and reinforcement learning techniques to deliver optimal performance.

### Different Models Offered by GPT-3

The [GPT-3 language models](https://beta.openai.com/docs/models/gpt-3) have the ability to understand and generate natural language. Four main language models are available, each with varying levels of power and capabilities to suit different tasks.

*   `text-davinci-003`: It is the most advanced and capable language model in the GPT-3 family. It is capable of completing any task that the other models can perform, often with higher quality, longer output, and better ability to follow instructions. Additionally, it has the ability to insert completions within the text
*   `text-curie-001`: It is highly capable, but faster and more cost-effective than Davinci.
*   `text-babbage-001`: It can complete straightforward tasks efficiently and at a lower cost compared to other models.
*   `text-ada-001`: It is capable of performing simple tasks quickly and at a low cost. It is typically the fastest model in the GPT-3 family.

Out of the above four, you’ll use the `text-davinci-003` for text completion in this tutorial as it yields the best results.

## Getting Your OpenAI API Key

OpenAI provides different APIs to interact with its AI models. It provides you free credit worth $18 to experiment for the first three months.

Follow the steps below to get your free OpenAI API key:

1.  Go to [OpenAI API](https://openai.com/api/) and sign up for a free account. Follow the instructions, and you’ll be redirected to the API Dashboard.

2.  Click on your profile picture to view the menu bar, and then click on *View API Keys* to go to the *API Keys* page.

    ![](/images/Screenshot\_2023-01-02\_141710.png)

3.  Click on *Create new secret key* to create a new API Key.

    ![](/images/Screenshot\_2023-01-02\_141730.png)

4.  Copy the API Key and store it safely to use later in the tutorial.

    ![](/images/Screenshot\_2023-01-02\_141752.png)

## Prerequisites

Before you get started with the tutorial, you should have installed:

*   [Node.js(V14 or later)](https://docs.medusajs.com/tutorial/set-up-your-development-environment#nodejs)
*   [Git](https://docs.medusajs.com/tutorial/set-up-your-development-environment/#git)
*   [Medusa CLI](https://docs.medusajs.com/tutorial/set-up-your-development-environment#medusa-cli)
*   [Redis](https://docs.medusajs.com/tutorial/set-up-your-development-environment/#redis)

## Setting up Your Medusa Development Environment

In this section, you’ll create a Medusa server where you’ll integrate ChatGPT in the next step.

### Setting up Your Medusa Server

Create a new Medusa store called `my-medusa-store` and seed the test data using the following command:

```
medusa new my-medusa-store --seed
```

Start your Medusa server using the following command:

```
cd my-medusa-store
medusa develop
```

The above two steps take a couple of minutes to set up and run your server on port 9000. You can test your server by going to `http://localhost:9000/store/products` on your browser or by running the following command:

```
curl localhost:9000/store/products
```

If you get a list of products, your server is successfully set up.

## Create a Subscriber to Handle Empty Descriptions

In this section, you’ll create a subscriber in your Medusa server that will listen to the `product.created` event. The subscriber then calls a function to handle the description field of the product. If the description field is empty, another function will be called to interact with ChatGPT’s `text-davinci-003` language model.

While you can directly interact with the models using their APIs, OpenAI also provides you with several [official](https://beta.openai.com/docs/libraries/libraries) and [community libraries](https://beta.openai.com/docs/libraries/community-libraries) for different languages.

Install the official OpenAI library in your Medusa server:

```
npm install openai
```

Add the `OPENAI_API_KEY` in the `.env` file in your Medusa server:

```
OPENAI_API_KEY=your-api-key-here
```

> Note: Replace the value of `your-api-key-here` with a valid API key that you obtained from OpenAI earlier in the tutorial.

Since you’re going to create a subscriber in your Medusa server, make sure you enable Redis in the `medusa-config.js`:

```
module.exports = {
  projectConfig: {
    redis_url: REDIS_URL, // Enable Redis Here
		//...
  },
  plugins,
};
```

Create a `description.js` file inside `src/subscribers` directory in the Medusa server and add the following content:

```
import { Configuration, OpenAIApi } from "openai";

const configuration = new Configuration({
  apiKey: process.env.OPENAI_API_KEY, // Replace with your API key
});

class DescriptionSubscriber {
  constructor({ productService, eventBusService }) {
    this.productService_ = productService;
    eventBusService.subscribe("product.created", this.handleDescription);
  }
  handleDescription = async (data) => {
    let productDescription = "";

    const product = await this.productService_.retrieve(data.id);
    if (product.description == null) {
      try {
        const productName = product.title;
        const productFeatures = [product.subtitle, product.material];
        const prompt = `Write a product description for ${productName}, which has the following features: ${productFeatures.join(
          ", "
        )}.`;

        productDescription = await this.prepareDescription(prompt);
      } catch (error) {
        const errorMessage = error.response.data.error.message;
        console.error("Error: " + errorMessage);
        return;
      }

			product.description = productDescription;
      await this.productService_.update(product.id, product);
    }
  };

  prepareDescription = async (
    prompt,
    model = "text-davinci-003",
    temperature = 0.7,
    maxTokens = 256,
    topP = 1,
    frequencyPenalty = 0,
    presencePenalty = 0
  ) => {
    const openai = new OpenAIApi(configuration);

    const response = await openai.createCompletion({
      model,
      prompt,
      temperature,
      max_tokens: maxTokens,
      top_p: topP,
      frequency_penalty: frequencyPenalty,
      presence_penalty: presencePenalty,
    });

    return response.data.choices[0].text.trim();
  };
}

export default DescriptionSubscriber;
```

In the above code, you import the `Configuration` class from the `openai` module and then create a new `Configuration` object using the `Configuration` class. The `Configuration` object is initialized with an API key for the OpenAI API.

You also define a subscriber called `DescriptionSubscriber` which includes a constructor and two methods: `handleDescription` and `prepareDescription`.

The `constructor` method subscribes to an event called `product.created` using the `eventBusService` and specifies that the `handleDescription` method should be called whenever this event is emitted.

The `handleDescription` method is an async function that is called with a `data` argument. As mentioned [in the documentation](https://docs.medusajs.com/advanced/backend/subscribers/events-list#product-events), the event data payload, i.e., the `data` argument contains just the `id` of the created product. This method retrieves a product from the `productService` using the `id` property of the `data` object.

If the `description` of the product is `null`, the method generates a description using the `prepareDescription` method and updates the product with the new description.

`prepareDescription` is an async function that is used to generate product descriptions using OpenAI's [Text Completion API](https://beta.openai.com/docs/guides/completion/text-completion). The function takes several parameters as inputs:

*   `prompt`: a string that specifies the text prompt that the API should use as a starting point for generating text. In this case, the text that asks for a description of a product by its properties such as name, material, etc.

*   `model`: (optional, default: `"text-davinci-003"`) a string that specifies the ID of the model that should be used to generate text.

*   `temperature`: (optional, default: `0.7`) a float that specifies the sampling temperature to use when generating text.

*   `maxTokens`: (optional, default: `256`) an integer that specifies the maximum number of [tokens](https://beta.openai.com/docs/introduction/tokens) (i.e., words or word pieces) that should be generated.

*   `topP`: (optional, default: `1`) a float that specifies the "top-p" value to use when generating text. Higher values will produce more conservative and deterministic output, while lower values will allow for more randomness and diversity in the output.

*   `frequencyPenalty`: (optional, default: `0`) a float that specifies the frequency penalty to use when generating text. Higher values will produce more diverse output, while lower values will allow the model to reuse more common tokens.

*   `presencePenalty`: (optional, default: `0`) a float that specifies the presence penalty to use when generating text.

The function creates an instance of the `OpenAIApi` class, which is used to communicate with the OpenAI API, and then calls the `createCompletion` method on this instance to generate text.

## Testing the Flow

Once you’ve made the required changes in your Medusa server, you’ll need to build your project using the command:

```
npm run build
```

Next, you can restart your server using the command:

```
medusa develop
```

### Setting up Your Medusa Admin

You can test the flow both from the Medusa Admin and the [Admin APIs](https://docs.medusajs.com/api/admin/). In this case, you’ll test using the Medusa Admin.

Medusa Admin is an intuitively designed admin dashboard for your ecommerce Medusa server. Medusa Admin is built with Vite 3 and React. It allows merchants to manage their data such as products, orders, discounts, regions, and more.

Follow the steps to set up your Medusa Admin and create products:

Clone the Medusa Admin GitHub repository and change your path to the cloned directory:

```
git clone https://github.com/medusajs/admin my-medusa-admin
cd my-medusa-admin
```

Install the dependencies using the following command:

```
npm install
```

Once all the dependencies are installed, run the Admin server using the following command:

```
npm run start
```

The Medusa Admin runs on port 7000, so go to `http://localhost:7000` in your browser to open your Admin Panel.

![](/images/Screenshot\_2023-01-02\_153211.png)

Since you’ve already seeded the data in your Medusa server, you can use the email `admin@medusa-test.com` and password `supersecret` to log in.

### Creating Products in Medusa Admin

Click on the `Products` tab on the left side and then click on the `New Product` button.

![](/images/Screenshot\_2023-01-05\_102325-173349ed.png)

Since the admin is configured to fetch the products right after the product is created, which is before the subscriber runs, you’ll need to refresh the page to see the changes. You can customize the admin to refetch the product after it’s created to resolve this.

![](/images/Screenshot\_2023-01-05\_102712.png)

Once you publish a product without a description, your product will initially be created with an empty description. The `product.created` event is then emitted, and the `DescriptionSubscriber` is triggered.

Since the description is empty, the subscriber uses the `prepareDescription` function to generate a description and updates the description of the product.

![](/images/Screenshot\_2023-01-05\_102525.png)

## Conclusion

In this tutorial, you learned how you can use ChatGPT to automate writing your product description. You can add more product features such as its price, variants, and more to generate a more unique description.

This integration was made easy due to Medusa’s composable architecture. You can learn more about Medusa through its [documentation](https://docs.medusajs.com/). Here are some documents that you can start with:

*   Set up a [Next.js](https://docs.medusajs.com/starters/nextjs-medusa-starter) or [Gatsby](https://docs.medusajs.com/starters/gatsby-medusa-starter) storefront.
*   Integrate [Stripe](https://docs.medusajs.com/add-plugins/stripe) as a payment provider.
*   Create a [custom endpoint](https://docs.medusajs.com/advanced/backend/endpoints/add).

> Should you have any issues or questions related to Medusa, then feel free to reach out to the Medusa team via [Discord](https://discord.gg/F87eGuwkTp).




#[Introducing Medusa Express](https://www.producthunt.com/posts/medusa-express)⚡️

##What if you could buy and sell products via a link that sends you directly to check-out?

---

Wanted to share a cool new open-source project that we have been building for our [headless commerce engine](https://www.medusajs.com/). Medusa Express is a one-page checkout flow allowing you to purchase a product directly via a URL-link which can be smart in cases of e.g. retargeting campaigns, outbound sales, special releases, or bloggers that want to sell easily to their followers.

Medusa Express automatically creates pages for the products in your ecommerce backend each of them optimized to make the purchasing experience as frictionless as possible, by bundling the checkout flow alongside the product.

Access it in the top link!

**How it works:**

1. A customer visits a link e.g. https://www.medusa.express/t-shirt

2. The customer selects the variant of the product they wish to buy

3. Customer completes the checkout flow and the order is completedHope you might find it relevant!


Introducing Medusa.Express: Open source one-page checkout-flow

Sharing Medusa Express, our new one-page checkout flow allowing purchases directly through a URL-link.

Introducing Medusa Express⚡️

What if you could buy and sell products via a link that sends you directly to check-out?

Stay up to date

Up Next

Use ChatGPT to Automate Product Description Writing

You may also like

Ecommerce APIs: What they are and how they work

Multi-currency Ecommerce: How to Take Multiple Currencies in Your Storefront

Composable Ecommerce platform explained

Inspired by Git: How we Designed our Order-Editing Feature

Order Edits and Payment Collections are now available

Ecommerce APIs: What they are and how they work

Multi-currency Ecommerce: How to Take Multiple Currencies in Your Storefront

Composable Ecommerce platform explained

Inspired by Git: How we Designed our Order-Editing Feature