PostCartsIdPromotions

Instructions

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)
  },