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).



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).



For 2023, our main mission at [Medusa](https://github.com/medusajs/medusa) is to ensure our platform provides more extensibility and composability. So, our roadmap contains features that push our platform towards these goals.

Although we have many features planned out for 2023, this article focuses on features our team has already started on and are guaranteed to be shipped in the upcoming quarters.

Keep reading to learn about what’s in store for future versions of Medusa.

## Planning our Roadmap

At Medusa, we strive to implement high quality and advanced features for ecommerce businesses interested in the platform. We have a broad vision of the features that we want to implement, and the direction we want Medusa to move into.

This is reflected in our [Roadmap](https://github.com/medusajs/medusa/discussions/categories/roadmap). We constantly revisit and make additions to our roadmap to match our vision of the platform. The features in this article are only a subset of the features we are planning to implement in Medusa.

Aside from the roadmap, we’re introducing Rewind Weeks at Medusa in 2023. These will allow us to shed light on the features we shipped in a quarter, along with projects and tools that our team has built to further improve Medusa. We’ll share more details on this later.

## Select Features From Our 2023 Roadmap

### Multi-Warehouse API

As businesses expand into new markets and open physical stores, supply chains and logistics become much more complex. Without the right tools to manage the many moving parts, orders can get lost, and stock issues start to pile up.

Medusa already enables great integrations with OMS and IMS systems. But we are now adding a more sophisticated inventory layer that allows Medusa to support businesses with multiple distribution centers or retail stores natively.

Merchants can manage inventory across locations within Medusa and connect locations to sales channels to control stock availability.  Furthermore, we will introduce allocations to ensure safety stock and avoid overselling. This will give merchants a clear picture of their inventory at any given point.

The new feature will enable a wide range of new experiences for customers, such as buy-online-pick-up-in-store or reserve-online-try-in-store flows. Developers will also get an excellent new API that can be used to optimize fulfillment, build POS experiences, and further push the boundaries of what can be done within digital commerce.

![](/images/Multi-location_inventory_support.png)

### **Payment Processor API**

One of Medusa’s core strengths is its composable architecture, which allows integrating it with the best-in-breed tools that accelerate ecommerce growth.

From the beginning, offering the best payment option to your customers at any time has been a core feature of Medusa. Medusa already allows merchants to attach as many payment processors — such as Stripe, PayPal, and Klarna — as they want and, with powerful multi-regional logic, control which options are shown to the customer at checkout.

With our new Payment Processor API, we will unlock even more capabilities and make it easier for plugin developers to create integrations with payment processors worldwide.

Simultaneously, the new Payment Processor API will enable better support for RMA flows requiring payments. We recently released Order Editing, which allows merchants to modify orders after they have been placed.

Edits can result in discrepancies between the order total and paid total, and with the new Payment Processor API, we are making it simpler to collect payments for differences.

### Nested Categories

Medusa currently allows merchants to organize their products by Collections to be used in storefronts or for internal business logic. For example, they can be used for controlling whether discounts can be applied to a group of products.

In the near future, we will introduce an additional way to manage your product hierarchy and create better experiences for your customers. Nested Categories will allow you to define category hierarchies like Women’s > Bottoms > Skirts to better organize product navigation on storefronts.

Furthermore, adding the same product to multiple categories will be possible, enabling better merchandising functionality right within the Medusa dashboard.

As always with Medusa, you own your data and can extend and customize the behavior of our APIs. This is also the case with Nested Categories, enabling developers to create enhanced search and browsing experiences while adding a new, powerful reporting dimension to your product catalog.

![https://user-images.githubusercontent.com/5105988/209083628-bc28d3eb-23a0-44a1-beb3-438c60511160.png](https://user-images.githubusercontent.com/5105988/209083628-bc28d3eb-23a0-44a1-beb3-438c60511160.png)

### **EventBus Modules**

Medusa emits hundreds of events that plugins use to send transactional emails, automate tedious tasks, and reliably integrate systems in your stack.

The existing event system uses Redis with BullMQ to enable Pub/Sub functionality. Many larger Medusa implementations will, however, already have an event architecture in place.

With the new EventBus Modules, it will be possible to integrate your existing events architecture directly into Medusa.

This will enable new EventBus providers like RabbitMQ, Kafka, or Amazon SQS, and improve Medusa’s compatibility with microservice architectures.

### Automated API specs and typing

Medusa’s API reference is automated to ensure that the documentation is always up-to-date with the core API. As part of our dedication to [improving our documentation](https://medusajs.com/blog/how-we-improved-our-documentation/), we are enhancing how we document the API with code and simultaneously creating new automations to generate our client library.

This will remove inconsistencies between server logic, documentation, and client library support.

We will, furthermore, be able to eliminate the current dependency on `@medusajs/medusa` in our client library, which will help reduce the bundle size of storefront implementations.

### Medusa Admin extensibility

One of Medusa’s principles is to build strong defaults that make it quick and easy to get started, and simultaneously offer a fantastic developer experience that enables customizations and extensions to make Medusa your bespoke commerce engine.

We have followed that principle diligently in our backend implementations until now. But our Admin dashboard has long been more locked and harder to customize. We are prioritizing changing that very soon.

Our first step will be to move our admin dashboard to an NPM package that can spin up with your Medusa server. This will improve the developer experience when building with Medusa, as you will no longer have to clone the admin project, merge updates, or start it separately from your Medusa server.

![](/images/Screenshot\_2023-01-11\_at\_6.46.06\_PM_sirvel.png)

Additionally, we will follow semantic versioning of the admin package to avoid version mismatches between the admin application and the core medusa package.

The next step hereafter will open up extension areas in the admin dashboard to add custom UI elements like buttons, cards, or entire pages. Custom elements can be created in your local project or shipped with plugins to package server and admin functionality easily.

## Conclusion

As mentioned earlier, this Roadmap overview includes only the features we started implementing. There are more upcoming features and enhancements in our Roadmap, which you can check out in our [GitHub Discussions](https://github.com/medusajs/medusa/discussions/categories/roadmap).

What features are you excited for? And what features do you think we should include in our Roadmap?

> 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).



Roadmap update - Jan 2023

Deploy a Medusa Server on AWS with Microtica

[Medusa](https://github.com/medusajs/medusa) is an open source composable commerce platform built for developers. Its architecture is flexible enabling users to build bespoke commerce solutions.

Medusa is composed of three components:

1.  A headless backend engine that holds all the logic and data of the store and exposes APIs to communicate with the admin and storefront,
2.  An admin dashboard that allows store operators to manage their orders and products, and
3.  A storefront, which is ultimately an ecommerce website where customers can preview products and make orders.

## What is Microtica?

[Microtica](https://www.microtica.com/) is a developer self-service platform that enables you to self-host open source solutions on AWS (Amazon Web Services) without being a cloud expert.

The platform provides production-ready templates for development frameworks and solutions, so you can get started fast and be free from the friction of dealing with the underlying cloud complexities.

Using the templates, you can deliver on your own AWS account and deploy applications/services on Amazon EKS (Elastic Kubernetes Service).

## Why Should You Deploy Medusa Server on AWS?

Here are some of the reasons why it would be a good idea to deploy a Medusa.js Server on AWS with Microtica’s template:

*   Out-of-the-box serverless infrastructure with Fargate
*   Infrastructure and data ownership on your AWS account
*   Auto-scaling based on application load
*   Automated git-push deployments and rollbacks
*   Production-ready solution
*   Resource monitoring and performance insights in-app

## Prerequisites

To follow through with this tutorial, here’s a list of things you should have/do.

*   Have a Git account; any provider from GitHub, BitBucket, GitLab, and CodeCommit is supported.
*   [Create a Microtica account](https://app.microtica.com/auth/signup?utm_source=devto\&utm_medium=blog\&utm_campaign=deploy+medusa+on+aws) by signing up with your email or your Git account.
*   Have an AWS account to be able to deploy a React app to your AWS account. You can [sign up for an AWS account here.](https://aws.amazon.com/)

## Deploy a New Medusa Server

After creating a Microtica account, click the *Deploy with Microtica* button to land on the *Templates* page, where you can see a list of all production-ready templates.

![](/images//THXCHbFZq6.jpg)

This template creates the following infrastructure resources that will be provisioned on your AWS account:

*   VPC, subnets and networking
*   Container infrastructure based on Fargate
*   Application load balancer
*   Persistent storage
*   S3 bucket
*   Postgres database
*   Redis (in production mode)

The steps to deploying a new Medusa server are outlined below.

### Create a Git Repository

Connect your preferred Git account. Microtica will create a repository on your Git account with a default repo name `medusa-server`.

![](/images//nTZPm9Fyis.png)

### Configure Template

Here, you can customize the template for your needs by providing environment variables. Enter an application name and the admin credentials that will be used to create an initial admin user with which you can later sign in to your Medusa Admin.

Select whether you want a production Medusa Server environment or a development one. In production mode, this template will provision managed RDS PostgreSQL and Redis instances. In development mode, the template will use local SQLite and a fake Redis instance.

![](/images//ujvPPLbsyo.png)

Environment variables can be updated, added, or configured after deployment as well.

### Connect an AWS account

In the last step, you can select the environment in which you want to deploy the template. An existing default environment called `development` will be preselected here or you can create a new environment.

Connect your AWS account when prompted. This process takes only a few seconds, so afterwards, only choose the region you want to deploy in.

![](/images//rHQmxc0rBJ.png)

### Deploy the Medusa Server Template to AWS

Finally, a deployment summary of what will be provisioned on your AWS account is presented.

![](/images//vwUF_K9zRz.png)

Clicking the *Deploy* button will trigger a deployment of the template and start creating the infrastructure for a Medusa Server.

It will take about 10 mins for the solution to be deployed on the cloud; you can follow the build pipeline in real time by clicking the *View Logs* button.

![](/images//TcfKjLjkLe.png)

Once the build process is complete, a new deployment with the infrastructure resources is triggered. You can follow the logs of the deployment process by clicking the *View deployment* button, and then selecting the deployment from the list.

![](/images//thr0qC6h4m.png)

### Preview the Environment

After the deployment is finished, navigate to *Resources* → [*AppName*](https://dev.tomedusa%20in%20our%20case/) → *Overview*, and under *Resource Outputs* you should see the AccessUrl.

This is the server URL that you can use to access API endpoints. Try getting the list of products using the endpoint `/store/products`.

![](/images//Y284EZGh1U.png)

The image below shows how your environment should look after deploying both templates.

![](/images//jNxhPN9Afv.png)

## Cleanup

To remove all the resources created on your AWS account, navigate to your environment → *Environment Settings* → *Infrastructure*, and you’ll see the *Undeploy* section.

This will clean up the resources created in AWS, but you will still have the configuration in Microtica in case you want to deploy it in the cloud again.

## Deploy an Existing Medusa Server

If you already have an existing Medusa server repository that you want to migrate to AWS, there are several changes you need to make to your source code. You can follow [the documentation](https://docs.microtica.com/medusa-server?utm_source=devto\&utm_medium=blog\&utm_campaign=deploy+medusa+on+aws) to configure and import your Medusa server repo code.

> 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).



Learn how to deploy Medusa on AWS with Microtica

A Step-by-Step Tutorial on How to Deploy a Medusa Server on AWS


A quick guide by our CTO, Oliver, on how to deploy your [Medusa](https://www.medusajs.com/) ecommerce backend to Heroku.

> We assume, that you are currently running a local instance of Medusa. If not, check out our [Quickstart](https://docs.medusajs.com/quickstart/quick-start) or use `npx create-medusa-app` to quickly set up your application. For the latter, see [this guide](https://docs.medusajs.com/how-to/create-medusa-app) for a short walkthrough.

After this tutorial, you will have a live headless commerce backend to start your ecommerce store from.

{% embed https://www.youtube.com/watch?v=nqZKnkrGMA0&ab_ %}

---

**For the written tutorial:** [https://docs.medusajs.com/how-to/deploying-on-heroku/](https://docs.medusajs.com/how-to/deploying-on-heroku/)

Should you have any problems setting this up, then feel free to hit us up on our [Discord](https://discord.com/invite/medusajs).

Hope you found the tutorial helpful!


Video: Deploy your Medusa store on Heroku in 5 minutes

In this video, we'll deploy your Medusa ecommerce backend to Heroku in 5 minutes

Stay up to date

Up Next

A Step-by-Step Tutorial on How to Deploy a Medusa Server on AWS

You may also like

Use ChatGPT to Automate Product Description Writing

Roadmap update - Jan 2023

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

Use ChatGPT to Automate Product Description Writing

Roadmap update - Jan 2023

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

Order Edits and Payment Collections are now available