PostCartsIdCustomer

Instructions

Implementation Reference

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

  The core handler logic for the PostCartsIdCustomer tool. It processes input parameters into query or body based on OpenAPI spec, then calls the Medusa JS SDK's client.fetch method to execute the POST /carts/{id}/customer API request.

      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-81 (schema)

  Dynamically generates the Zod input schema for PostCartsIdCustomer (and other store tools) based on the OpenAPI parameters from store.json, mapping types to Zod schemas.

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

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

  The defineTools method generates and returns the list of all store tools, including PostCartsIdCustomer, by iterating over the OpenAPI paths in store.json and wrapping each into a tool definition.

  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/index.ts:35-42 (registration)

  Registers all tools from store and admin services (including PostCartsIdCustomer) with the MCP server using server.tool().

  tools.forEach((tool) => {
      server.tool(
          tool.name,
          tool.description,
          tool.inputSchema,
          tool.handler
      );
  });

• src/utils/define-tools.ts:16-60 (helper)

  Utility function used to define each tool, wrapping the custom handler with error handling and MCP response formatting (JSON stringified output).

  export const defineTool = (
      cb: (zod: typeof z) => ToolDefinition<any, ZodAny, any>
  ) => {
      const tool = cb(z);
  
      const wrappedHandler = async (
          input: InferToolHandlerInput<Zod.ZodAny, Zod.ZodAny>,
          _: RequestHandlerExtra
      ): Promise<{
          content: CallToolResult["content"];
          isError?: boolean;
          statusCode?: number;
      }> => {
          try {
              const result = await tool.handler(input);
              return {
                  content: [
                      {
                          type: "text",
                          text: JSON.stringify(result, null, 2)
                      }
                  ]
              };
          } catch (error) {
              return {
                  content: [
                      {
                          type: "text",
                          text: `Error: ${
                              error instanceof Error
                                  ? error.message
                                  : String(error)
                          }`
                      }
                  ],
                  isError: true
              };
          }
      };
  
      return {
          ...tool,
          handler: wrappedHandler
      };
  };