@yoryoboy/bi-mcp 1.11.0 → 1.13.0

package/dist/tests/meli/mercadolibre-tool-handlers-small.test.js

@@ -0,0 +1,626 @@
+import { beforeEach, describe, expect, it, vi } from "vitest";
+import { meliGetAccountContextHandler } from "../../src/tools/mercadolibre/get-account-context.js";
+import { meliValidateConnectionHandler } from "../../src/tools/mercadolibre/validate-connection.js";
+import { meliPredictCategoryHandler } from "../../src/tools/mercadolibre/predict-category.js";
+import { meliGetCategoryRequirementsHandler } from "../../src/tools/mercadolibre/get-category-requirements.js";
+import { meliEstimateListingFeeHandler } from "../../src/tools/mercadolibre/estimate-listing-fee.js";
+import { meliGetSiteCategoriesAndListingTypesHandler } from "../../src/tools/mercadolibre/get-site-categories-and-listing-types.js";
+import { meliGetItemDetailsHandler } from "../../src/tools/mercadolibre/get-item-details.js";
+import { meliSearchQuestionsHandler } from "../../src/tools/mercadolibre/search-questions.js";
+import { meliAnswerQuestionHandler } from "../../src/tools/mercadolibre/answer-question.js";
+import { meliGetListingQualityHandler } from "../../src/tools/mercadolibre/get-listing-quality.js";
+import { meliGetItemVisitsHandler } from "../../src/tools/mercadolibre/get-item-visits.js";
+import { resolveMercadoLibreProfileOrSelection } from "../../src/tools/mercadolibre/profile-resolution.js";
+import {
+  buildMercadoLibreWriteSuccessResponse,
+  handleMercadoLibreWriteError,
+  resolveMercadoLibreWriteProfile
+} from "../../src/tools/mercadolibre/write-helpers.js";
+import { getMercadoLibreAccessForProfile } from "../../src/config/mercadolibre.js";
+import { getMercadoLibreConnectionRow } from "../../src/config/mercadolibre-profile-store.js";
+import {
+  buildMercadoLibrePaginationMetadata,
+  formatMercadoLibreError,
+  getMercadoLibreUsersMe,
+  normalizeMercadoLibrePaging
+} from "../../src/services/mercadolibre/mercadolibre-api.js";
+import {
+  getMercadoLibreCategoryAttributes,
+  getMercadoLibreCategoryShippingPreferences,
+  getMercadoLibreItemDetailsBatch,
+  getMercadoLibreItemDetailsWithFallbackBatch,
+  getMercadoLibreItemPerformance,
+  getMercadoLibreItemVisitsWindow,
+  getMercadoLibreSiteCategoriesAndListingTypes,
+  getMercadoLibreUserItemsVisits,
+  searchMercadoLibreDomainDiscovery
+} from "../../src/services/mercadolibre/mercadolibre-items.js";
+import {
+  answerMercadoLibreQuestion,
+  searchMercadoLibreQuestions
+} from "../../src/services/mercadolibre/mercadolibre-questions.js";
+import { buildMercadoLibreListingFeeEstimate } from "../../src/tools/mercadolibre/listing-fee-helpers.js";
+vi.mock("mcp-use/server", () => ({
+  object: vi.fn((payload) => ({ kind: "object", payload })),
+  error: vi.fn((message) => ({ kind: "error", message }))
+}));
+vi.mock("../../src/tools/mercadolibre/profile-resolution.js", () => ({
+  resolveMercadoLibreProfileOrSelection: vi.fn()
+}));
+vi.mock("../../src/tools/mercadolibre/write-helpers.js", async () => {
+  const { z } = await import("zod");
+  return {
+    mercadolibreProfileIdSchemaField: z.string().optional(),
+    resolveMercadoLibreWriteProfile: vi.fn(),
+    buildMercadoLibreWriteSuccessResponse: vi.fn((payload) => ({ kind: "success", payload })),
+    handleMercadoLibreWriteError: vi.fn(
+      (err, fallback) => ({
+        kind: "error",
+        message: `write:${fallback}:${err instanceof Error ? err.message : String(err)}`
+      })
+    )
+  };
+});
+vi.mock("../../src/config/mercadolibre.js", () => ({
+  getMercadoLibreAccessForProfile: vi.fn()
+}));
+vi.mock("../../src/config/mercadolibre-profile-store.js", () => ({
+  getMercadoLibreConnectionRow: vi.fn()
+}));
+vi.mock("../../src/services/mercadolibre/mercadolibre-api.js", () => ({
+  getMercadoLibreUsersMe: vi.fn(),
+  formatMercadoLibreError: vi.fn(
+    (err, fallback) => `formatted:${fallback}:${err instanceof Error ? err.message : String(err)}`
+  ),
+  normalizeMercadoLibrePaging: vi.fn((paging) => paging),
+  buildMercadoLibrePaginationMetadata: vi.fn((metadata) => metadata)
+}));
+vi.mock("../../src/services/mercadolibre/mercadolibre-items.js", () => ({
+  searchMercadoLibreDomainDiscovery: vi.fn(),
+  getMercadoLibreCategoryAttributes: vi.fn(),
+  getMercadoLibreCategoryShippingPreferences: vi.fn(),
+  getMercadoLibreSiteCategoriesAndListingTypes: vi.fn(),
+  getMercadoLibreItemDetailsBatch: vi.fn(),
+  getMercadoLibreItemDetailsWithFallbackBatch: vi.fn(),
+  getMercadoLibreItemPerformance: vi.fn(),
+  getMercadoLibreItemVisitsWindow: vi.fn(),
+  getMercadoLibreUserItemsVisits: vi.fn()
+}));
+vi.mock("../../src/services/mercadolibre/mercadolibre-questions.js", () => ({
+  searchMercadoLibreQuestions: vi.fn(),
+  answerMercadoLibreQuestion: vi.fn()
+}));
+vi.mock("../../src/tools/mercadolibre/listing-fee-helpers.js", () => ({
+  buildMercadoLibreListingFeeEstimate: vi.fn()
+}));
+describe("MercadoLibre small and medium tool handlers", () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    vi.mocked(resolveMercadoLibreProfileOrSelection).mockResolvedValue({
+      ok: true,
+      value: { profileId: "meli-profile-1" }
+    });
+    vi.mocked(resolveMercadoLibreWriteProfile).mockResolvedValue({
+      ok: true,
+      value: { profileId: "meli-profile-1" }
+    });
+    vi.mocked(getMercadoLibreAccessForProfile).mockResolvedValue({
+      sellerId: "seller-99",
+      scopes: ["read", "write"],
+      expiresAt: "2026-07-01T00:00:00.000Z"
+    });
+    vi.mocked(getMercadoLibreUsersMe).mockResolvedValue({
+      id: 12345,
+      nickname: "meli-store"
+    });
+    vi.mocked(buildMercadoLibrePaginationMetadata).mockImplementation((metadata) => metadata);
+    vi.mocked(normalizeMercadoLibrePaging).mockImplementation((paging) => paging);
+  });
+  it("returns MercadoLibre account context with resolved profile access", async () => {
+    const result = await meliGetAccountContextHandler({ profileId: "custom-profile" });
+    expect(resolveMercadoLibreProfileOrSelection).toHaveBeenCalledWith("custom-profile");
+    expect(getMercadoLibreAccessForProfile).toHaveBeenCalledWith("meli-profile-1");
+    expect(getMercadoLibreUsersMe).toHaveBeenCalledWith("meli-profile-1");
+    expect(result).toEqual({
+      kind: "object",
+      payload: {
+        profile_id: "meli-profile-1",
+        seller_id: "seller-99",
+        nickname: "meli-store",
+        account_id: 12345,
+        scopes: ["read", "write"],
+        expires_at: "2026-07-01T00:00:00.000Z"
+      }
+    });
+  });
+  it("returns profile selection payload unchanged for read handlers", async () => {
+    vi.mocked(resolveMercadoLibreProfileOrSelection).mockResolvedValue({
+      ok: false,
+      response: { selection_required: true }
+    });
+    const result = await meliGetAccountContextHandler({ profileId: void 0 });
+    expect(result).toEqual({ selection_required: true });
+    expect(getMercadoLibreAccessForProfile).not.toHaveBeenCalled();
+  });
+  it("validates connection and reports refresh detection", async () => {
+    vi.mocked(getMercadoLibreConnectionRow).mockResolvedValueOnce({
+      expiresAt: /* @__PURE__ */ new Date("2026-06-01T00:00:00.000Z"),
+      encryptedAccessToken: "old-token"
+    }).mockResolvedValueOnce({
+      status: "active",
+      expiresAt: /* @__PURE__ */ new Date("2026-07-01T00:00:00.000Z"),
+      encryptedAccessToken: "new-token"
+    });
+    const result = await meliValidateConnectionHandler({ profileId: "meli-profile-1" });
+    expect(result).toEqual({
+      kind: "object",
+      payload: {
+        profile_id: "meli-profile-1",
+        validation_status: "active",
+        refreshed: true,
+        seller_id: "seller-99",
+        account_id: 12345,
+        nickname: "meli-store",
+        expires_at: "2026-07-01T00:00:00.000Z",
+        scopes: ["read", "write"]
+      }
+    });
+  });
+  it("predicts categories with normalized candidate payloads and defaults", async () => {
+    vi.mocked(searchMercadoLibreDomainDiscovery).mockResolvedValue([
+      {
+        category_id: "MLA123",
+        category_name: "Sneakers",
+        domain_id: "MLA-SNEAKERS",
+        domain_name: "Sneakers",
+        attributes_matched: "4"
+      }
+    ]);
+    const result = await meliPredictCategoryHandler({
+      profileId: "meli-profile-1",
+      query: "running shoes"
+    });
+    expect(searchMercadoLibreDomainDiscovery).toHaveBeenCalledWith(
+      "meli-profile-1",
+      "running shoes",
+      5,
+      "MLA"
+    );
+    expect(result).toEqual({
+      kind: "object",
+      payload: {
+        profile_id: "meli-profile-1",
+        query: "running shoes",
+        site_id: "MLA",
+        candidates: [
+          {
+            category_id: "MLA123",
+            category_name: "Sneakers",
+            domain_id: "MLA-SNEAKERS",
+            domain_name: "Sneakers",
+            attributes_matched: 4
+          }
+        ]
+      }
+    });
+  });
+  it("splits required and recommended category requirements", async () => {
+    vi.mocked(getMercadoLibreCategoryAttributes).mockResolvedValue([
+      {
+        id: "BRAND",
+        name: "Brand",
+        value_type: "string",
+        value_max_length: 255,
+        tags: { required: true }
+      },
+      {
+        id: "MODEL",
+        name: "Model",
+        value_type: "string",
+        tags: {}
+      }
+    ]);
+    vi.mocked(getMercadoLibreCategoryShippingPreferences).mockResolvedValue({
+      mode: "me2",
+      logistic_types: ["drop_off"]
+    });
+    const result = await meliGetCategoryRequirementsHandler({
+      profileId: "meli-profile-1",
+      categoryId: "MLA999"
+    });
+    expect(result).toEqual({
+      kind: "object",
+      payload: {
+        profile_id: "meli-profile-1",
+        category_id: "MLA999",
+        required_attributes: [
+          {
+            id: "BRAND",
+            name: "Brand",
+            value_type: "string",
+            value_max_length: 255
+          }
+        ],
+        recommended_attributes: [
+          {
+            id: "MODEL",
+            name: "Model",
+            value_type: "string"
+          }
+        ],
+        shipping_preferences: {
+          mode: "me2",
+          logistics: ["drop_off"]
+        }
+      }
+    });
+  });
+  it("delegates listing fee estimation with the resolved profile", async () => {
+    vi.mocked(buildMercadoLibreListingFeeEstimate).mockResolvedValue({
+      profile_id: "meli-profile-1",
+      fee_amount: 1234,
+      site_id: null
+    });
+    const result = await meliEstimateListingFeeHandler({
+      profileId: "meli-profile-1",
+      itemId: "MLA1",
+      query: "running shoes",
+      price: 1e4,
+      categoryId: "MLA123",
+      listingTypeId: "gold_special",
+      shippingMode: "me2",
+      logisticType: "drop_off",
+      billableWeight: 1200,
+      currencyId: "ARS",
+      tags: ["test-tag"]
+    });
+    expect(buildMercadoLibreListingFeeEstimate).toHaveBeenCalledWith({
+      profileId: "meli-profile-1",
+      itemId: "MLA1",
+      query: "running shoes",
+      price: 1e4,
+      categoryId: "MLA123",
+      listingTypeId: "gold_special",
+      shippingMode: "me2",
+      logisticType: "drop_off",
+      billableWeight: 1200,
+      currencyId: "ARS",
+      tags: ["test-tag"]
+    });
+    expect(result).toEqual({
+      kind: "object",
+      payload: {
+        profile_id: "meli-profile-1",
+        fee_amount: 1234
+      }
+    });
+  });
+  it("combines site categories and listing types metadata", async () => {
+    vi.mocked(getMercadoLibreSiteCategoriesAndListingTypes).mockResolvedValue({
+      siteId: "MLA",
+      categories: [{ id: "MLA1", name: "Shoes" }],
+      listingTypes: [{ id: "gold_special", name: "Cl\xE1sica" }]
+    });
+    const result = await meliGetSiteCategoriesAndListingTypesHandler({ profileId: "meli-profile-1" });
+    expect(result).toEqual({
+      kind: "object",
+      payload: {
+        profile_id: "meli-profile-1",
+        site_id: "MLA",
+        categories: [{ id: "MLA1", name: "Shoes" }],
+        listing_types: [{ id: "gold_special", name: "Cl\xE1sica" }],
+        metadata: {
+          site_id: "MLA",
+          categories_count: 1,
+          listing_types_count: 1,
+          pagination: "No aplica. La tool consolida dos endpoints de cat\xE1logo del sitio MLA en una sola respuesta."
+        }
+      }
+    });
+  });
+  it("returns item details directly from multiget when all requested ids are found", async () => {
+    vi.mocked(getMercadoLibreItemDetailsBatch).mockResolvedValue([
+      { id: "MLA1", title: "Boots", pictures: [{ id: "1" }], status: "active" },
+      { id: "MLA2", title: "Sneakers", pictures: [{ id: "2" }], status: "paused" }
+    ]);
+    const result = await meliGetItemDetailsHandler({
+      profileId: "meli-profile-1",
+      itemIds: ["MLA1", "MLA1", "MLA2"]
+    });
+    expect(getMercadoLibreItemDetailsBatch).toHaveBeenCalledWith("meli-profile-1", ["MLA1", "MLA2"]);
+    expect(result).toEqual({
+      kind: "object",
+      payload: {
+        metadata: {
+          profile_id: "meli-profile-1",
+          requested: 2,
+          successful: 2,
+          failed: 0,
+          source: "items_multiget"
+        },
+        items: [
+          { id: "MLA1", title: "Boots", status: "active" },
+          { id: "MLA2", title: "Sneakers", status: "paused" }
+        ]
+      }
+    });
+  });
+  it("falls back to item-by-item details when multiget coverage is partial", async () => {
+    vi.mocked(getMercadoLibreItemDetailsBatch).mockResolvedValue([{ id: "MLA1", title: "Boots" }]);
+    vi.mocked(getMercadoLibreItemDetailsWithFallbackBatch).mockResolvedValue({
+      successful: [
+        {
+          id: "MLA1",
+          document: { id: "MLA1", title: "Boots" }
+        }
+      ],
+      failed: [
+        {
+          id: "MLA2",
+          message: "not found",
+          statusCode: 404,
+          attempts: 2,
+          retryable: false
+        }
+      ]
+    });
+    const result = await meliGetItemDetailsHandler({
+      profileId: "meli-profile-1",
+      itemIds: ["MLA1", "MLA2"]
+    });
+    expect(result).toEqual({
+      kind: "object",
+      payload: {
+        metadata: {
+          profile_id: "meli-profile-1",
+          requested: 2,
+          successful: 1,
+          failed: 1,
+          has_failures: true,
+          source: "item_by_item_fallback"
+        },
+        items: [{ id: "MLA1", title: "Boots" }],
+        failures: [
+          {
+            item_id: "MLA2",
+            message: "not found",
+            status_code: 404,
+            attempts: 2,
+            retryable: false
+          }
+        ]
+      }
+    });
+  });
+  it("searches questions with seller context and normalized pagination", async () => {
+    vi.mocked(searchMercadoLibreQuestions).mockResolvedValue({
+      questions: [
+        {
+          id: 777,
+          item_id: "MLA1",
+          item: { title: "Boots" },
+          status: "unanswered",
+          text: "Do you ship today?",
+          date_created: "2026-03-10T14:45:55.000Z",
+          from: { id: 555, nickname: "buyer" },
+          answer: { status: "not_answered" }
+        }
+      ],
+      paging: { total: 1, limit: 20, offset: 0 }
+    });
+    const result = await meliSearchQuestionsHandler({ profileId: "meli-profile-1" });
+    expect(searchMercadoLibreQuestions).toHaveBeenCalledWith("meli-profile-1", {
+      sellerId: "seller-99",
+      itemId: void 0,
+      status: void 0,
+      limit: 20,
+      offset: 0
+    });
+    expect(result).toEqual({
+      kind: "object",
+      payload: {
+        profile_id: "meli-profile-1",
+        metadata: {
+          total: 1,
+          limit: 20,
+          offset: 0,
+          returned: 1,
+          nextField: "offset"
+        },
+        questions: [
+          {
+            question_id: 777,
+            item_id: "MLA1",
+            item_title: "Boots",
+            status: "unanswered",
+            text: "Do you ship today?",
+            date_created: "2026-03-10 14:45",
+            from: { id: "", nickname: "buyer" },
+            answer_status: "not_answered"
+          }
+        ]
+      }
+    });
+  });
+  it("routes question answers through write helpers", async () => {
+    vi.mocked(answerMercadoLibreQuestion).mockResolvedValue({ id: 777, status: "answered" });
+    const result = await meliAnswerQuestionHandler({
+      profileId: "meli-profile-1",
+      questionId: 777,
+      text: "Yes, we can ship today."
+    });
+    expect(resolveMercadoLibreWriteProfile).toHaveBeenCalledWith("meli-profile-1");
+    expect(answerMercadoLibreQuestion).toHaveBeenCalledWith(
+      "meli-profile-1",
+      777,
+      "Yes, we can ship today."
+    );
+    expect(buildMercadoLibreWriteSuccessResponse).toHaveBeenCalledWith({
+      profileId: "meli-profile-1",
+      operation: "answer_question",
+      resourceId: "777",
+      message: "MercadoLibre question answered successfully.",
+      after: { id: 777, status: "answered" }
+    });
+    expect(result).toEqual({
+      kind: "success",
+      payload: {
+        profileId: "meli-profile-1",
+        operation: "answer_question",
+        resourceId: "777",
+        message: "MercadoLibre question answered successfully.",
+        after: { id: 777, status: "answered" }
+      }
+    });
+  });
+  it("formats listing quality summaries with warning normalization", async () => {
+    vi.mocked(getMercadoLibreItemPerformance).mockResolvedValue({
+      score: "85",
+      status: "healthy",
+      health: "good",
+      sales: 20,
+      visits: 300,
+      warnings: [{ id: "photo", text: "Add more photos", severity: "medium" }],
+      item: { title: "Boots", status: "active" }
+    });
+    const result = await meliGetListingQualityHandler({
+      profileId: "meli-profile-1",
+      itemId: "MLA1"
+    });
+    expect(result).toEqual({
+      kind: "object",
+      payload: {
+        profile_id: "meli-profile-1",
+        item_id: "MLA1",
+        quality_score: 85,
+        level: "healthy",
+        health: "good",
+        sales: 20,
+        visits: 300,
+        warnings: [
+          {
+            type: "photo",
+            message: "Add more photos",
+            severity: "medium"
+          }
+        ],
+        raw_summary: {
+          title: "Boots",
+          status: "active"
+        }
+      }
+    });
+  });
+  it("returns item-level visits windows when item ids are provided", async () => {
+    vi.mocked(getMercadoLibreItemVisitsWindow).mockResolvedValue({
+      total_visits: 14,
+      results: [{ date: "2026-03-10", visits: 14 }]
+    });
+    const result = await meliGetItemVisitsHandler({
+      profileId: "meli-profile-1",
+      itemIds: ["MLA1", "MLA1"],
+      last: 7,
+      ending: "2026-03-10"
+    });
+    expect(getMercadoLibreItemVisitsWindow).toHaveBeenCalledTimes(1);
+    expect(result).toEqual({
+      kind: "object",
+      payload: {
+        profile_id: "meli-profile-1",
+        seller_id: "seller-99",
+        total_visits: 14,
+        items: [
+          {
+            item_id: "MLA1",
+            total_visits: 14,
+            last: 7,
+            unit: "day",
+            ending: "2026-03-10",
+            time_window: [{ date: "2026-03-10", visits: 14 }]
+          }
+        ]
+      }
+    });
+  });
+  it("returns a validation error when visits are requested without item ids or date range", async () => {
+    const result = await meliGetItemVisitsHandler({ profileId: "meli-profile-1" });
+    expect(result).toEqual({
+      kind: "error",
+      message: "Provide itemIds, or provide both startDate and endDate for seller-level visits."
+    });
+    expect(getMercadoLibreUserItemsVisits).not.toHaveBeenCalled();
+  });
+  it("returns seller-level visits when a date range is provided", async () => {
+    vi.mocked(getMercadoLibreUserItemsVisits).mockResolvedValue({
+      results: [
+        { item_id: "MLA1", total_visits: 10 },
+        { id: "MLA2", visits: 4 }
+      ]
+    });
+    const result = await meliGetItemVisitsHandler({
+      profileId: "meli-profile-1",
+      startDate: "2026-03-01",
+      endDate: "2026-03-10"
+    });
+    expect(getMercadoLibreUserItemsVisits).toHaveBeenCalledWith(
+      "meli-profile-1",
+      "seller-99",
+      "2026-03-01",
+      "2026-03-10"
+    );
+    expect(result).toEqual({
+      kind: "object",
+      payload: {
+        profile_id: "meli-profile-1",
+        seller_id: "seller-99",
+        total_visits: 14,
+        item_visit_rows: [
+          { item_id: "MLA1", total_visits: 10 },
+          { item_id: "MLA2", total_visits: 4 }
+        ]
+      }
+    });
+  });
+  it("formats service failures through MercadoLibre error helpers", async () => {
+    vi.mocked(getMercadoLibreUsersMe).mockRejectedValue(new Error("boom"));
+    const result = await meliValidateConnectionHandler({ profileId: "meli-profile-1" });
+    expect(formatMercadoLibreError).toHaveBeenCalledWith(
+      expect.any(Error),
+      "Failed to validate MercadoLibre connection"
+    );
+    expect(result).toEqual({
+      kind: "error",
+      message: "formatted:Failed to validate MercadoLibre connection:boom"
+    });
+  });
+  it("returns write-helper selection payloads unchanged and skips answer calls", async () => {
+    vi.mocked(resolveMercadoLibreWriteProfile).mockResolvedValue({
+      ok: false,
+      response: { selection_required: true, provider: "mercadolibre" }
+    });
+    const result = await meliAnswerQuestionHandler({
+      profileId: void 0,
+      questionId: 777,
+      text: "Answer"
+    });
+    expect(result).toEqual({ selection_required: true, provider: "mercadolibre" });
+    expect(answerMercadoLibreQuestion).not.toHaveBeenCalled();
+  });
+  it("routes write failures through the MercadoLibre write error helper", async () => {
+    vi.mocked(answerMercadoLibreQuestion).mockRejectedValue(new Error("cannot-answer"));
+    const result = await meliAnswerQuestionHandler({
+      profileId: "meli-profile-1",
+      questionId: 888,
+      text: "Answer"
+    });
+    expect(handleMercadoLibreWriteError).toHaveBeenCalledWith(
+      expect.any(Error),
+      "Failed to answer MercadoLibre question 888"
+    );
+    expect(result).toEqual({
+      kind: "error",
+      message: "write:Failed to answer MercadoLibre question 888:cannot-answer"
+    });
+  });
+});
+//# sourceMappingURL=mercadolibre-tool-handlers-small.test.js.map