Redis Cloud API MCP Server

Instructions

Implementation Reference

• src/tools/subscriptions/essentials/index.ts:226-244 (handler)

  Handler function that executes the deletion of an essential subscription by ID. Extracts and validates subscriptionId, calls the service method deleteSubscriptionById1, and returns the result.

  "delete-essential-subscription": async (request) => {
    const { subscriptionId } = extractArguments<{ subscriptionId: number }>(
      request,
    );
  
    // Validate input
    validateToolInput(
      subscriptionIdSchema,
      { subscriptionId },
      "Essential subscription ID",
    );
  
    const result = await executeApiCall(
      () =>
        SubscriptionsEssentialsService.deleteSubscriptionById1(subscriptionId),
      `Delete essential subscription ${subscriptionId}`,
    );
    return createToolResponse(result);
  },

• src/tools/subscriptions/essentials/index.ts:114-128 (schema)

  Tool schema definition specifying the input schema requiring a subscriptionId (number >=1).

  const DELETE_ESSENTIAL_SUBSCRIPTION_TOOL: Tool = {
    name: "delete-essential-subscription",
    description: "Delete an essential subscription by ID",
    inputSchema: {
      type: "object",
      properties: {
        subscriptionId: {
          type: "number",
          description: "Subscription ID",
          min: 1,
        },
      },
      required: ["subscriptionId"],
    },
  };

• src/tools/subscriptions/essentials/index.ts:163-169 (registration)

  Registration of the delete-essential-subscription tool as part of the SUBSCRIPTIONS_ESSENTIALS_TOOLS array export.

  export const SUBSCRIPTIONS_ESSENTIALS_TOOLS = [
    GET_ESSENTIAL_SUBSCRIPTIONS_TOOL,
    GET_ESSENTIAL_SUBSCRIPTION_BY_ID_TOOL,
    CREATE_ESSENTIAL_SUBSCRIPTION_TOOL,
    DELETE_ESSENTIAL_SUBSCRIPTION_TOOL,
    GET_ESSENTIALS_PLANS_TOOL,
  ];

• src/tools/subscriptions/essentials/index.ts:171-336 (registration)

  Export of handlers object including the delete-essential-subscription handler.

  export const SUBSCRIPTIONS_ESSENTIALS_HANDLERS: ToolHandlers = {
    "get-essential-subscriptions": async (request) => {
      const { page = 0, size = DEFAULT_PAGE_SIZE } = extractArguments<{
        page?: number;
        size?: number;
      }>(request);
  
      // Validate input
      validateToolInput(
        getSubscriptionsSchema,
        { page, size },
        "Essential subscriptions request",
      );
  
      const response = await executeApiCall(
        () => SubscriptionsEssentialsService.getAllSubscriptions1(),
        "Get essential subscriptions",
      );
  
      const allSubscriptions = response.subscriptions || [];
  
      // Calculate pagination
      const startIndex = page * size;
      const endIndex = startIndex + size;
      const paginatedSubscriptions = allSubscriptions.slice(startIndex, endIndex);
  
      const pageable: Pageable = {
        page,
        size,
      };
  
      return createToolResponse(
        createPage(paginatedSubscriptions, pageable, allSubscriptions.length),
      );
    },
  
    "get-essential-subscription-by-id": async (request) => {
      const { subscriptionId } = extractArguments<{ subscriptionId: number }>(
        request,
      );
  
      // Validate input
      validateToolInput(
        subscriptionIdSchema,
        { subscriptionId },
        "Essential subscription ID",
      );
  
      const subscription = await executeApiCall(
        () => SubscriptionsEssentialsService.getSubscriptionById1(subscriptionId),
        `Get essential subscription ${subscriptionId}`,
      );
      return createToolResponse(subscription);
    },
  
    "delete-essential-subscription": async (request) => {
      const { subscriptionId } = extractArguments<{ subscriptionId: number }>(
        request,
      );
  
      // Validate input
      validateToolInput(
        subscriptionIdSchema,
        { subscriptionId },
        "Essential subscription ID",
      );
  
      const result = await executeApiCall(
        () =>
          SubscriptionsEssentialsService.deleteSubscriptionById1(subscriptionId),
        `Delete essential subscription ${subscriptionId}`,
      );
      return createToolResponse(result);
    },
  
    "get-essentials-plans": async (request) => {
      const {
        provider,
        redisFlex,
        page = 0,
        size = DEFAULT_PAGE_SIZE,
      } = extractArguments<{
        provider: "AWS" | "GCP" | "AZURE";
        redisFlex: boolean;
        page?: number;
        size?: number;
      }>(request);
  
      // Validate input
      validateToolInput(
        getPlansSchema,
        { provider, redisFlex, page, size },
        "Essential plans request",
      );
  
      const response = await executeApiCall(
        () =>
          SubscriptionsEssentialsService.getAllFixedSubscriptionsPlans(
            provider,
            redisFlex,
          ),
        `Get essential plans for ${provider}`,
      );
  
      const allPlans = response.plans.map((plan) => ({
        id: plan.id,
        name: plan.name,
        size: plan.size,
        sizeMeasurementUnit: plan.sizeMeasurementUnit,
        regionId: plan.regionId,
        price: plan.price,
        priceCurrency: plan.priceCurrency,
        pricePeriod: plan.pricePeriod,
      }));
  
      // Calculate pagination
      const startIndex = page * size;
      const endIndex = startIndex + size;
      const paginatedPlans = allPlans.slice(startIndex, endIndex);
  
      const pageable: Pageable = {
        page,
        size,
      };
  
      return createToolResponse(
        createPage(paginatedPlans, pageable, allPlans.length),
      );
    },
  
    "create-essential-subscription": async (request) => {
      const { name, planId, paymentMethod, paymentMethodId } = extractArguments<{
        name: string;
        planId: number;
        paymentMethod?: FixedSubscriptionCreateRequest["paymentMethod"];
        paymentMethodId?: number;
      }>(request);
  
      // Validate input
      validateToolInput(
        createSubscriptionSchema,
        { name, planId, paymentMethod, paymentMethodId },
        "Create essential subscription",
      );
  
      // If paymentMethod is credit-card, paymentMethodId is required
      if (paymentMethod === "credit-card" && !paymentMethodId) {
        throw new Error(
          "paymentMethodId is required when paymentMethod is credit-card",
        );
      }
  
      const reqBody: FixedSubscriptionCreateRequest = {
        name,
        planId,
        ...(paymentMethod && { paymentMethod }),
        ...(paymentMethodId && { paymentMethodId }),
      };
  
      const result = await executeApiCall(
        () => SubscriptionsEssentialsService.createSubscription1(reqBody),
        "Create essential subscription",
      );
      return createToolResponse(result);
    },
  };