PostCartsIdPromotions

Add promotions to a shopping cart in Medusa to apply discounts or special offers during checkout.

Instructions

Add a list of promotions to a cart.

Input Schema

TableJSON Schema

Name	Required	Description	Default
`id`	No
`fields`	No

Implementation Reference

src/index.ts:35-42 (registration)
Registers all tools, including PostCartsIdPromotions, on the MCP server by calling server.tool for each tool from services.
```
tools.forEach((tool) => {
    server.tool(
        tool.name,
        tool.description,
        tool.inputSchema,
        tool.handler
    );
});
```
src/index.ts:14-17 (registration)
Calls defineTools on MedusaStoreService to get the list of store tools, including PostCartsIdPromotions.
```
tools = [
    ...medusaStoreService.defineTools(),
    ...medusaAdminService.defineTools()
];
```

src/services/medusa-store.ts:131-137 (helper)

Generates all store API tools by iterating over OpenAPI spec paths and wrapping each with wrapPath, including the one for PostCartsIdPromotions.

defineTools(store = storeJson): any[] {
    const paths = Object.entries(store.paths) as [string, SdkRequestType][];
    const tools = paths.map(([path, refFunction]) =>
        this.wrapPath(path, refFunction)
    );
    return tools;
}

src/services/medusa-store.ts:83-126 (handler)

Handler logic for the PostCartsIdPromotions tool (and all store POST tools): constructs query/body from input, calls Medusa SDK fetch with POST method to the specific refPath for carts/{id}/promotions.

handler: async (
    input: InferToolHandlerInput<any, ZodTypeAny>
): Promise<any> => {
    const query = new URLSearchParams(input);
    const body = Object.entries(input).reduce(
        (acc, [key, value]) => {
            if (
                parameters.find(
                    (p) => p.name === key && p.in === "body"
                )
            ) {
                acc[key] = value;
            }
            return acc;
        },
        {} as Record<string, any>
    );
    if (method === "get") {
        console.error(
            `Fetching ${refPath} with GET ${query.toString()}`
        );
        const response = await this.sdk.client.fetch(refPath, {
            method: method,
            headers: {
                "Content-Type": "application/json",
                "Accept": "application/json",
                "Authorization": `Bearer ${process.env.PUBLISHABLE_KEY}`
            },
            query: query
        });
        return response;
    } else {
        const response = await this.sdk.client.fetch(refPath, {
            method: method,
            headers: {
                "Content-Type": "application/json",
                "Accept": "application/json",
                "Authorization": `Bearer ${process.env.PUBLISHABLE_KEY}`
            },
            body: JSON.stringify(body)
        });
        return response;
    }
}

src/services/medusa-store.ts:54-82 (schema)

Dynamically generates the input schema for PostCartsIdPromotions from the OpenAPI parameters of the /carts/{id}/promotions endpoint.

inputSchema: {
    ...parameters
        .filter((p) => p.in != "header")
        .reduce((acc, param) => {
            switch (param.schema.type) {
                case "string":
                    acc[param.name] = z.string().optional();
                    break;
                case "number":
                    acc[param.name] = z.number().optional();
                    break;
                case "boolean":
                    acc[param.name] = z.boolean().optional();
                    break;
                case "array":
                    acc[param.name] = z
                        .array(z.string())
                        .optional();
                    break;
                case "object":
                    acc[param.name] = z.object({}).optional();
                    break;
                default:
                    acc[param.name] = z.string().optional();
            }
            return acc;
        }, {} as any)
},

Medusa MCP Server