@yoryoboy/bi-mcp 1.10.0 → 1.13.0

package/dist/tests/vtex/vtex-catalog-write-tools.test.js

@@ -0,0 +1,712 @@
+import { beforeEach, describe, expect, it, vi } from "vitest";
+import { z } from "zod";
+import { associateSpecificationHandler } from "../../src/tools/vtex/associate-specification.js";
+import { createBrandHandler } from "../../src/tools/vtex/create-brand.js";
+import { createCategoryHandler } from "../../src/tools/vtex/create-category.js";
+import { createProductHandler } from "../../src/tools/vtex/create-product.js";
+import { createSkuHandler } from "../../src/tools/vtex/create-sku.js";
+import {
+  createSpecificationHandler,
+  createSpecificationSchema
+} from "../../src/tools/vtex/create-specification.js";
+import { createSpecificationValueHandler } from "../../src/tools/vtex/create-specification-value.js";
+import {
+  associateProductSpecification,
+  associateSkuSpecification,
+  createBrand,
+  createCategory,
+  createProduct,
+  createSku,
+  createSkuEan,
+  createSpecification,
+  createSpecificationValue
+} from "../../src/services/vtex/vtex-catalog-write.js";
+import {
+  buildWriteSuccessResponse,
+  handleVtexWriteError,
+  resolveVtexWriteProfile
+} from "../../src/tools/vtex/write-helpers.js";
+vi.mock("../../src/tools/vtex/write-helpers.js", () => ({
+  vtexProfileIdSchemaField: z.string().optional(),
+  confirmationSchemaField: z.boolean().optional(),
+  confirmationNoteSchemaField: z.string().optional(),
+  resolveVtexWriteProfile: vi.fn(),
+  buildWriteSuccessResponse: vi.fn((params) => ({
+    kind: "success",
+    params
+  })),
+  handleVtexWriteError: vi.fn((err, fallback) => ({
+    kind: "error",
+    fallback,
+    err
+  }))
+}));
+vi.mock("../../src/services/vtex/vtex-catalog-write.js", () => ({
+  createBrand: vi.fn(),
+  createCategory: vi.fn(),
+  createProduct: vi.fn(),
+  createSku: vi.fn(),
+  createSkuEan: vi.fn(),
+  createSpecification: vi.fn(),
+  createSpecificationValue: vi.fn(),
+  associateProductSpecification: vi.fn(),
+  associateSkuSpecification: vi.fn()
+}));
+describe("VTEX catalog/specification write tools", () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    vi.mocked(resolveVtexWriteProfile).mockResolvedValue({
+      ok: true,
+      value: { profileId: "profile-1" }
+    });
+  });
+  describe("createBrandHandler", () => {
+    it("applies default payload values before creating a brand", async () => {
+      const createdBrand = { Id: 10, Name: "Nike", Active: true };
+      vi.mocked(createBrand).mockResolvedValue(createdBrand);
+      const result = await createBrandHandler({
+        profileId: "custom",
+        id: 10,
+        name: "Nike",
+        linkId: "nike"
+      });
+      expect(createBrand).toHaveBeenCalledWith("profile-1", {
+        Id: 10,
+        Name: "Nike",
+        Text: "Nike",
+        Keywords: "",
+        SiteTitle: "Nike",
+        Active: true,
+        MenuHome: false,
+        LinkId: "nike",
+        Score: null,
+        AdWordsRemarketingCode: null,
+        LomadeeCampaignCode: null
+      });
+      expect(buildWriteSuccessResponse).toHaveBeenCalledWith({
+        profileId: "profile-1",
+        operation: "create_brand",
+        resourceId: "10",
+        riskLevel: "low",
+        message: "Brand created successfully.",
+        before: null,
+        after: createdBrand
+      });
+      expect(result).toEqual({
+        kind: "success",
+        params: expect.objectContaining({ operation: "create_brand" })
+      });
+    });
+    it("returns profile selection payload when profile resolution fails", async () => {
+      vi.mocked(resolveVtexWriteProfile).mockResolvedValue({
+        ok: false,
+        response: { selection: true }
+      });
+      const result = await createBrandHandler({ id: 10, name: "Nike" });
+      expect(result).toEqual({ selection: true });
+      expect(createBrand).not.toHaveBeenCalled();
+    });
+    it("maps service errors through handleVtexWriteError", async () => {
+      vi.mocked(createBrand).mockRejectedValue(new Error("boom"));
+      const result = await createBrandHandler({
+        profileId: "custom",
+        id: 10,
+        name: "Nike"
+      });
+      expect(handleVtexWriteError).toHaveBeenCalledWith(
+        expect.any(Error),
+        "Failed to create brand in VTEX"
+      );
+      expect(result).toEqual({
+        kind: "error",
+        fallback: "Failed to create brand in VTEX",
+        err: expect.any(Error)
+      });
+    });
+  });
+  describe("createCategoryHandler", () => {
+    it("forwards the expected VTEX category payload with defaults", async () => {
+      const createdCategory = { Id: 20, Name: "Shoes" };
+      vi.mocked(createCategory).mockResolvedValue(createdCategory);
+      const result = await createCategoryHandler({
+        profileId: "custom",
+        name: "Shoes",
+        title: "Running Shoes",
+        description: "Category description",
+        fatherCategoryId: null,
+        globalCategoryId: 123,
+        stockKeepingUnitSelectionMode: "SPECIFICATION"
+      });
+      expect(createCategory).toHaveBeenCalledWith("profile-1", {
+        Id: void 0,
+        Name: "Shoes",
+        Keywords: "",
+        Title: "Running Shoes",
+        Description: "Category description",
+        AdWordsRemarketingCode: null,
+        LomadeeCampaignCode: null,
+        FatherCategoryId: null,
+        GlobalCategoryId: 123,
+        ShowInStoreFront: true,
+        IsActive: true,
+        ActiveStoreFrontLink: true,
+        ShowBrandFilter: true,
+        Score: null,
+        StockKeepingUnitSelectionMode: "SPECIFICATION"
+      });
+      expect(buildWriteSuccessResponse).toHaveBeenCalledWith({
+        profileId: "profile-1",
+        operation: "create_category",
+        resourceId: "20",
+        riskLevel: "low",
+        message: "Category created successfully.",
+        before: null,
+        after: createdCategory
+      });
+      expect(result).toEqual({
+        kind: "success",
+        params: expect.objectContaining({ operation: "create_category" })
+      });
+    });
+    it("returns profile selection payload when profile resolution fails", async () => {
+      vi.mocked(resolveVtexWriteProfile).mockResolvedValue({
+        ok: false,
+        response: { selection: true }
+      });
+      const result = await createCategoryHandler({
+        name: "Shoes",
+        title: "Running Shoes",
+        description: "Category description",
+        globalCategoryId: 123,
+        stockKeepingUnitSelectionMode: "SPECIFICATION"
+      });
+      expect(result).toEqual({ selection: true });
+      expect(createCategory).not.toHaveBeenCalled();
+    });
+    it("maps service errors through handleVtexWriteError", async () => {
+      vi.mocked(createCategory).mockRejectedValue(new Error("boom"));
+      const result = await createCategoryHandler({
+        profileId: "custom",
+        name: "Shoes",
+        title: "Running Shoes",
+        description: "Category description",
+        globalCategoryId: 123,
+        stockKeepingUnitSelectionMode: "SPECIFICATION"
+      });
+      expect(handleVtexWriteError).toHaveBeenCalledWith(
+        expect.any(Error),
+        "Failed to create category in VTEX"
+      );
+      expect(result).toEqual({
+        kind: "error",
+        fallback: "Failed to create category in VTEX",
+        err: expect.any(Error)
+      });
+    });
+  });
+  describe("createProductHandler", () => {
+    it("forwards the expected VTEX product payload and builds a success response", async () => {
+      const createdProduct = { Id: 55, Name: "Running Shoe" };
+      vi.mocked(createProduct).mockResolvedValue(createdProduct);
+      const result = await createProductHandler({
+        profileId: "custom",
+        name: "Running Shoe",
+        categoryPath: "Mens/Shoes/Running",
+        brandName: "Acme",
+        departmentId: 7,
+        refId: "RUN-001",
+        title: "Running Shoe",
+        description: "Main description",
+        descriptionShort: "Short description",
+        linkId: "running-shoe",
+        releaseDate: "2026-06-01T00:00:00Z",
+        keyWords: "running,shoe",
+        isVisible: true,
+        isActive: false,
+        taxCode: "TX-1",
+        metaTagDescription: "Meta description",
+        supplierId: 91,
+        showWithoutStock: true,
+        score: 12
+      });
+      expect(createProduct).toHaveBeenCalledWith("profile-1", {
+        Name: "Running Shoe",
+        CategoryPath: "Mens/Shoes/Running",
+        BrandName: "Acme",
+        DepartmentId: 7,
+        RefId: "RUN-001",
+        Title: "Running Shoe",
+        Description: "Main description",
+        DescriptionShort: "Short description",
+        LinkId: "running-shoe",
+        ReleaseDate: "2026-06-01T00:00:00Z",
+        KeyWords: "running,shoe",
+        IsVisible: true,
+        IsActive: false,
+        TaxCode: "TX-1",
+        MetaTagDescription: "Meta description",
+        SupplierId: 91,
+        ShowWithoutStock: true,
+        Score: 12
+      });
+      expect(buildWriteSuccessResponse).toHaveBeenCalledWith({
+        profileId: "profile-1",
+        operation: "create_product",
+        resourceId: "55",
+        riskLevel: "low",
+        message: "Product created successfully.",
+        before: null,
+        after: createdProduct,
+        details: {
+          product_id: "55"
+        }
+      });
+      expect(result).toEqual({
+        kind: "success",
+        params: expect.objectContaining({ operation: "create_product" })
+      });
+    });
+    it("returns profile selection payload when profile resolution fails", async () => {
+      vi.mocked(resolveVtexWriteProfile).mockResolvedValue({
+        ok: false,
+        response: { selection: true }
+      });
+      const result = await createProductHandler({
+        name: "Running Shoe",
+        categoryId: 10,
+        brandId: 20
+      });
+      expect(result).toEqual({ selection: true });
+      expect(createProduct).not.toHaveBeenCalled();
+    });
+    it("maps service errors through handleVtexWriteError", async () => {
+      vi.mocked(createProduct).mockRejectedValue(new Error("boom"));
+      const result = await createProductHandler({
+        profileId: "custom",
+        name: "Running Shoe",
+        categoryId: 10,
+        brandId: 20
+      });
+      expect(handleVtexWriteError).toHaveBeenCalledWith(
+        expect.any(Error),
+        "Failed to create product in VTEX"
+      );
+      expect(result).toEqual({
+        kind: "error",
+        fallback: "Failed to create product in VTEX",
+        err: expect.any(Error)
+      });
+    });
+  });
+  describe("createSkuHandler", () => {
+    const skuPayload = {
+      profileId: "custom",
+      productId: 99,
+      name: "Running Shoe / Black / 42",
+      refId: "RUN-001-42",
+      packagedHeight: 10,
+      packagedLength: 20,
+      packagedWidth: 30,
+      packagedWeightKg: 1.5,
+      height: 9,
+      length: 19,
+      width: 29,
+      weightKg: 1.25,
+      measurementUnit: "un",
+      unitMultiplier: 1,
+      manufacturerCode: "ACME-42",
+      commercialConditionId: 12
+    };
+    it("forwards the expected VTEX SKU payload with default flags", async () => {
+      const createdSku = { Id: 77, Name: skuPayload.name };
+      vi.mocked(createSku).mockResolvedValue(createdSku);
+      const result = await createSkuHandler(skuPayload);
+      expect(createSku).toHaveBeenCalledWith("profile-1", {
+        ProductId: 99,
+        Name: "Running Shoe / Black / 42",
+        RefId: "RUN-001-42",
+        PackagedHeight: 10,
+        PackagedLength: 20,
+        PackagedWidth: 30,
+        PackagedWeightKg: 1.5,
+        ActivateIfPossible: true,
+        IsActive: false,
+        Height: 9,
+        Length: 19,
+        Width: 29,
+        WeightKg: 1.25,
+        MeasurementUnit: "un",
+        UnitMultiplier: 1,
+        ManufacturerCode: "ACME-42",
+        CommercialConditionId: 12
+      });
+      expect(createSkuEan).not.toHaveBeenCalled();
+      expect(buildWriteSuccessResponse).toHaveBeenCalledWith({
+        profileId: "profile-1",
+        operation: "create_sku",
+        resourceId: "77",
+        riskLevel: "low",
+        message: "SKU created successfully.",
+        before: null,
+        after: createdSku,
+        details: {
+          product_id: 99,
+          sku_id: "77"
+        }
+      });
+      expect(result).toEqual({
+        kind: "success",
+        params: expect.objectContaining({ operation: "create_sku" })
+      });
+    });
+    it("creates the sku then attaches the EAN when provided", async () => {
+      const createdSku = { Id: 78, Name: skuPayload.name };
+      vi.mocked(createSku).mockResolvedValue(createdSku);
+      await createSkuHandler({
+        ...skuPayload,
+        ean: " 7791234567890 ",
+        isActive: true,
+        activateIfPossible: false
+      });
+      expect(createSku).toHaveBeenCalledWith("profile-1", {
+        ProductId: 99,
+        Name: "Running Shoe / Black / 42",
+        RefId: "RUN-001-42",
+        PackagedHeight: 10,
+        PackagedLength: 20,
+        PackagedWidth: 30,
+        PackagedWeightKg: 1.5,
+        ActivateIfPossible: false,
+        IsActive: true,
+        Height: 9,
+        Length: 19,
+        Width: 29,
+        WeightKg: 1.25,
+        MeasurementUnit: "un",
+        UnitMultiplier: 1,
+        ManufacturerCode: "ACME-42",
+        CommercialConditionId: 12
+      });
+      expect(createSkuEan).toHaveBeenCalledWith(
+        "profile-1",
+        "78",
+        "7791234567890"
+      );
+      expect(
+        vi.mocked(createSku).mock.invocationCallOrder[0]
+      ).toBeLessThan(vi.mocked(createSkuEan).mock.invocationCallOrder[0]);
+      expect(buildWriteSuccessResponse).toHaveBeenCalledWith(
+        expect.objectContaining({
+          after: expect.objectContaining({ Eans: ["7791234567890"] })
+        })
+      );
+    });
+    it("skips EAN attachment when EAN is missing or blank", async () => {
+      const createdSku = { Id: 79, Name: skuPayload.name };
+      vi.mocked(createSku).mockResolvedValue(createdSku);
+      await createSkuHandler({
+        ...skuPayload,
+        ean: "   "
+      });
+      expect(createSkuEan).not.toHaveBeenCalled();
+    });
+    it("returns profile selection payload when profile resolution fails", async () => {
+      vi.mocked(resolveVtexWriteProfile).mockResolvedValue({
+        ok: false,
+        response: { selection: true }
+      });
+      const result = await createSkuHandler({
+        productId: 99,
+        name: "Running Shoe / Black / 42",
+        refId: "RUN-001-42",
+        packagedHeight: 10,
+        packagedLength: 20,
+        packagedWidth: 30,
+        packagedWeightKg: 1.5
+      });
+      expect(result).toEqual({ selection: true });
+      expect(createSku).not.toHaveBeenCalled();
+      expect(createSkuEan).not.toHaveBeenCalled();
+    });
+    it("maps service errors through handleVtexWriteError", async () => {
+      vi.mocked(createSku).mockRejectedValue(new Error("boom"));
+      const result = await createSkuHandler(skuPayload);
+      expect(handleVtexWriteError).toHaveBeenCalledWith(
+        expect.any(Error),
+        "Failed to create SKU in VTEX"
+      );
+      expect(result).toEqual({
+        kind: "error",
+        fallback: "Failed to create SKU in VTEX",
+        err: expect.any(Error)
+      });
+    });
+  });
+  describe("createSpecificationHandler", () => {
+    it("schema converts fieldTypeId from string to number", () => {
+      const parsed = createSpecificationSchema.parse({
+        fieldTypeId: "4",
+        fieldGroupId: 12,
+        name: "Color"
+      });
+      expect(parsed.fieldTypeId).toBe(4);
+    });
+    it("fills default fields before creating a specification", async () => {
+      const createdSpecification = { Id: 30, Name: "Color" };
+      vi.mocked(createSpecification).mockResolvedValue(
+        createdSpecification
+      );
+      const result = await createSpecificationHandler({
+        profileId: "custom",
+        fieldTypeId: 4,
+        fieldGroupId: 12,
+        name: "Color"
+      });
+      expect(createSpecification).toHaveBeenCalledWith("profile-1", {
+        FieldTypeId: 4,
+        FieldGroupId: 12,
+        Name: "Color",
+        CategoryId: void 0,
+        Description: null,
+        Position: 0,
+        IsFilter: false,
+        IsRequired: false,
+        IsOnProductDetails: true,
+        IsStockKeepingUnit: false,
+        IsWizard: false,
+        IsActive: true,
+        IsTopMenuLinkActive: false,
+        IsSideMenuLinkActive: false,
+        DefaultValue: ""
+      });
+      expect(buildWriteSuccessResponse).toHaveBeenCalledWith({
+        profileId: "profile-1",
+        operation: "create_specification",
+        resourceId: "30",
+        riskLevel: "low",
+        message: "Specification created successfully.",
+        before: null,
+        after: createdSpecification
+      });
+      expect(result).toEqual({
+        kind: "success",
+        params: expect.objectContaining({ operation: "create_specification" })
+      });
+    });
+    it("returns profile selection payload when profile resolution fails", async () => {
+      vi.mocked(resolveVtexWriteProfile).mockResolvedValue({
+        ok: false,
+        response: { selection: true }
+      });
+      const result = await createSpecificationHandler({
+        fieldTypeId: 4,
+        fieldGroupId: 12,
+        name: "Color"
+      });
+      expect(result).toEqual({ selection: true });
+      expect(createSpecification).not.toHaveBeenCalled();
+    });
+    it("maps service errors through handleVtexWriteError", async () => {
+      vi.mocked(createSpecification).mockRejectedValue(new Error("boom"));
+      const result = await createSpecificationHandler({
+        profileId: "custom",
+        fieldTypeId: 4,
+        fieldGroupId: 12,
+        name: "Color"
+      });
+      expect(handleVtexWriteError).toHaveBeenCalledWith(
+        expect.any(Error),
+        "Failed to create specification in VTEX"
+      );
+      expect(result).toEqual({
+        kind: "error",
+        fallback: "Failed to create specification in VTEX",
+        err: expect.any(Error)
+      });
+    });
+  });
+  describe("createSpecificationValueHandler", () => {
+    it("fills default fields before creating a specification value", async () => {
+      const createdValue = { FieldValueId: 40, Name: "Red" };
+      vi.mocked(createSpecificationValue).mockResolvedValue(
+        createdValue
+      );
+      const result = await createSpecificationValueHandler({
+        profileId: "custom",
+        fieldId: 30,
+        name: "Red"
+      });
+      expect(createSpecificationValue).toHaveBeenCalledWith("profile-1", {
+        FieldId: 30,
+        Name: "Red",
+        IsActive: true,
+        Position: 0,
+        Text: null
+      });
+      expect(buildWriteSuccessResponse).toHaveBeenCalledWith({
+        profileId: "profile-1",
+        operation: "create_specification_value",
+        resourceId: "40",
+        riskLevel: "low",
+        message: "Specification value created successfully.",
+        before: null,
+        after: createdValue
+      });
+      expect(result).toEqual({
+        kind: "success",
+        params: expect.objectContaining({
+          operation: "create_specification_value"
+        })
+      });
+    });
+    it("returns profile selection payload when profile resolution fails", async () => {
+      vi.mocked(resolveVtexWriteProfile).mockResolvedValue({
+        ok: false,
+        response: { selection: true }
+      });
+      const result = await createSpecificationValueHandler({
+        fieldId: 30,
+        name: "Red"
+      });
+      expect(result).toEqual({ selection: true });
+      expect(createSpecificationValue).not.toHaveBeenCalled();
+    });
+    it("maps service errors through handleVtexWriteError", async () => {
+      vi.mocked(createSpecificationValue).mockRejectedValue(new Error("boom"));
+      const result = await createSpecificationValueHandler({
+        profileId: "custom",
+        fieldId: 30,
+        name: "Red"
+      });
+      expect(handleVtexWriteError).toHaveBeenCalledWith(
+        expect.any(Error),
+        "Failed to create specification value in VTEX"
+      );
+      expect(result).toEqual({
+        kind: "error",
+        fallback: "Failed to create specification value in VTEX",
+        err: expect.any(Error)
+      });
+    });
+  });
+  describe("associateSpecificationHandler", () => {
+    it("routes product associations to the product service and shapes optional payload fields", async () => {
+      const association = { success: true, id: "prod-1" };
+      vi.mocked(associateProductSpecification).mockResolvedValue(
+        association
+      );
+      const result = await associateSpecificationHandler({
+        profileId: "custom",
+        entityType: "product",
+        resourceId: "prod-1",
+        fieldId: 30,
+        fieldValueId: 40
+      });
+      expect(associateProductSpecification).toHaveBeenCalledWith(
+        "profile-1",
+        "prod-1",
+        {
+          FieldId: 30,
+          FieldValueId: 40
+        }
+      );
+      expect(associateSkuSpecification).not.toHaveBeenCalled();
+      expect(buildWriteSuccessResponse).toHaveBeenCalledWith({
+        profileId: "profile-1",
+        operation: "associate_specification",
+        resourceId: "prod-1",
+        riskLevel: "low",
+        message: "Specification associated successfully.",
+        before: null,
+        after: association,
+        details: { entity_type: "product" }
+      });
+      expect(result).toEqual({
+        kind: "success",
+        params: expect.objectContaining({
+          operation: "associate_specification"
+        })
+      });
+    });
+    it("routes sku associations to the sku service and keeps free-text payloads", async () => {
+      const association = { success: true, id: "sku-1" };
+      vi.mocked(associateSkuSpecification).mockResolvedValue(
+        association
+      );
+      await associateSpecificationHandler({
+        profileId: "custom",
+        entityType: "sku",
+        resourceId: "sku-1",
+        fieldId: 30,
+        text: "Blue"
+      });
+      expect(associateSkuSpecification).toHaveBeenCalledWith(
+        "profile-1",
+        "sku-1",
+        {
+          FieldId: 30,
+          Text: "Blue"
+        }
+      );
+      expect(associateProductSpecification).not.toHaveBeenCalled();
+    });
+    it("keeps both FieldValueId and Text when both are provided", async () => {
+      const association = { success: true, id: "sku-2" };
+      vi.mocked(associateSkuSpecification).mockResolvedValue(
+        association
+      );
+      await associateSpecificationHandler({
+        profileId: "custom",
+        entityType: "sku",
+        resourceId: "sku-2",
+        fieldId: 31,
+        fieldValueId: 41,
+        text: "Navy"
+      });
+      expect(associateSkuSpecification).toHaveBeenCalledWith(
+        "profile-1",
+        "sku-2",
+        {
+          FieldId: 31,
+          FieldValueId: 41,
+          Text: "Navy"
+        }
+      );
+    });
+    it("returns profile selection payload when profile resolution fails", async () => {
+      vi.mocked(resolveVtexWriteProfile).mockResolvedValue({
+        ok: false,
+        response: { selection: true }
+      });
+      const result = await associateSpecificationHandler({
+        entityType: "product",
+        resourceId: "prod-1",
+        fieldId: 30
+      });
+      expect(result).toEqual({ selection: true });
+      expect(associateProductSpecification).not.toHaveBeenCalled();
+      expect(associateSkuSpecification).not.toHaveBeenCalled();
+    });
+    it("maps service errors through handleVtexWriteError", async () => {
+      vi.mocked(associateProductSpecification).mockRejectedValue(
+        new Error("boom")
+      );
+      const result = await associateSpecificationHandler({
+        profileId: "custom",
+        entityType: "product",
+        resourceId: "prod-1",
+        fieldId: 30
+      });
+      expect(handleVtexWriteError).toHaveBeenCalledWith(
+        expect.any(Error),
+        "Failed to associate specification to product prod-1"
+      );
+      expect(result).toEqual({
+        kind: "error",
+        fallback: "Failed to associate specification to product prod-1",
+        err: expect.any(Error)
+      });
+    });
+  });
+});
+//# sourceMappingURL=vtex-catalog-write-tools.test.js.map