update_product_rate_plan_charge

Instructions

Implementation Reference

• src/tools/product_rate_plan_charges/updateRatePlanCharge.ts:245-291 (handler)

  The main handler function for update_product_rate_plan_charge. Parses input with Zod schema, fetches existing charge via chargeService.getRatePlanCharge(), merges user-provided fields with existing data via existingChargeToUpdateBody(), validates the merged body with validateMergedBody(), then calls chargeService.updateRatePlanCharge() to PUT the update via the API.

  async function handler(client: Client, args: Record<string, unknown> | undefined) {
    const parsed = schema.safeParse(args);
    if (!parsed.success) {
      return errorResult(parsed.error.errors.map((e) => e.message).join("; "));
    }
    const input = parsed.data;
    const { chargeId, chargeTier: inputChargeTier, ...restInput } = input;
  
    try {
      // Fetch existing charge so we can merge when user sends partial update (e.g. only price)
      const existing = await chargeService.getRatePlanCharge(client, chargeId);
      const existingBody = chargeService.existingChargeToUpdateBody(existing);
  
      // User payload: only include fields the user actually provided (defined), so we don't overwrite with undefined
      const userPayload: Record<string, unknown> = {};
      for (const [k, v] of Object.entries(restInput)) {
        if (v !== undefined) userPayload[k] = v;
      }
      if (inputChargeTier !== undefined) {
        userPayload.chargeTier = inputChargeTier.map((t) => ({
          ...t,
          price: normalizePriceToCents(t.price),
          priceFormat: t.priceFormat ?? "",
        }));
      }
  
      const merged: UpdateRatePlanChargeBody = {
        ...existingBody,
        ...userPayload,
      } as UpdateRatePlanChargeBody;
  
      // Ensure chargeTier tiers have priceFormat for API
      if (merged.chargeTier?.length) {
        merged.chargeTier = merged.chargeTier.map((t) => ({
          ...t,
          priceFormat: t.priceFormat ?? "",
        }));
      }
  
      validateMergedBody(merged);
  
      return handleToolCall(() => chargeService.updateRatePlanCharge(client, chargeId, merged));
    } catch (err) {
      const message = err instanceof Error ? err.message : String(err);
      return errorResult(message);
    }
  }

• src/tools/product_rate_plan_charges/updateRatePlanCharge.ts:72-91 (schema)

  Zod input schema defining the tool's input validation. Only chargeId is required; all other fields (name, chargeType, chargeModel, billCycleType, category, chargeTier, taxable, weight, description, endDateCondition, billingPeriod, billingTiming, billingPeriodAlignment, specificBillingPeriod, billCycleDay, weeklyBillCycleDay, monthlyBillCycleYear) are optional for partial updates.

  const schema = z.object({
    chargeId: z.string().min(1, "chargeId is required"),
    name: z.string().min(1).optional(),
    chargeType: z.enum(chargeTypeEnum).optional(),
    chargeModel: z.enum(chargeModelEnum).optional(),
    billCycleType: z.enum(billCycleTypeEnum).optional(),
    category: z.enum(["physical", "digital"]).optional(),
    chargeTier: z.array(chargeTierItemSchema).optional(),
    taxable: z.boolean().optional(),
    weight: z.coerce.number().int().min(0).optional(),
    description: z.string().optional(),
    endDateCondition: z.enum(["subscriptionEnd", "fixedPeriod"]).optional(),
    billingPeriod: z.enum(billingPeriodEnum).optional(),
    billingTiming: z.enum(billingTimingEnum).optional(),
    billingPeriodAlignment: z.enum(billingPeriodAlignmentEnum).optional(),
    specificBillingPeriod: z.number().int().optional(),
    billCycleDay: z.number().int().min(1).max(31).optional(),
    weeklyBillCycleDay: z.enum(weeklyBillCycleDayEnum).optional(),
    monthlyBillCycleYear: z.number().int().min(1).max(12).optional(),
  });

• src/tools/product_rate_plan_charges/updateRatePlanCharge.ts:293-296 (registration)

  Exports updateRatePlanChargeTool as a Tool object with the definition and handler.

  export const updateRatePlanChargeTool: Tool = {
    definition,
    handler,
  };

• src/tools/index.ts:49-57 (registration)

  The executeTool function finds the tool by name and calls its handler. The tool is registered via registerProductRatePlanChargeTools() on line 30, which includes updateRatePlanChargeTool.

  export async function executeTool(
    name: string,
    args: Record<string, unknown> | undefined,
    client: RebilliaClient
  ): Promise<ToolResult | undefined> {
    const tool = tools.find((t) => t.definition.name === name);
    if (!tool) return undefined;
    return tool.handler(client, args);
  }

• src/services/productRatePlanChargeServices.ts:209-223 (helper)

  The updateRatePlanCharge API service function that performs the actual PUT /product-rateplan-charges/{chargeId} HTTP call, filtering out undefined values and normalizing charge tiers before sending.

  export async function updateRatePlanCharge(
    client: Client,
    chargeId: string,
    body: UpdateRatePlanChargeBody
  ): Promise<unknown> {
    const payload = Object.fromEntries(
      Object.entries(body).filter(([, v]) => v !== undefined)
    ) as UpdateRatePlanChargeBody;
    if (payload.weight != null) payload.weight = Number(payload.weight);
    if (payload.chargeTier?.length) payload.chargeTier = normalizeChargeTier(payload.chargeTier);
    return client.put<unknown>(
      `/product-rateplan-charges/${chargeId}`,
      Object.keys(payload).length ? payload : undefined
    );
  }