@open-loyalty/mcp-server 1.0.3 → 1.3.1

package/dist/tools/campaign/handlers.d.ts

@@ -0,0 +1,42 @@
+import { CampaignListItem } from "../../types/schemas/campaign.js";
+import { SimulatedEffect, CampaignSimulateInput, CampaignCreateInput } from "./types.js";
+export declare function campaignList(input: {
+    storeCode?: string;
+    page?: number;
+    perPage?: number;
+    active?: boolean;
+    type?: string;
+    trigger?: string;
+}): Promise<{
+    campaigns: CampaignListItem[];
+    total: {
+        all?: number;
+        filtered?: number;
+    };
+}>;
+export declare function campaignGet(input: {
+    storeCode?: string;
+    campaignId: string;
+}): Promise<Record<string, unknown>>;
+export declare function campaignCreate(input: CampaignCreateInput): Promise<{
+    campaignId: string;
+}>;
+export declare function campaignUpdate(input: Record<string, unknown>): Promise<void>;
+export declare function campaignPatch(input: {
+    storeCode?: string;
+    campaignId: string;
+    active?: boolean;
+    displayOrder?: number;
+}): Promise<void>;
+export declare function campaignDelete(input: {
+    storeCode?: string;
+    campaignId: string;
+}): Promise<void>;
+export declare function campaignSimulate(input: CampaignSimulateInput): Promise<{
+    simulatedEffects: SimulatedEffect[];
+    evaluationWarnings?: Array<{
+        campaignId: string;
+        message: string;
+    }>;
+    simulatedMember?: Record<string, unknown>;
+}>;

package/dist/tools/campaign/handlers.js

@@ -0,0 +1,223 @@
+import { apiGet, apiPost, apiPut, apiPatch, apiDelete } from "../../client/http.js";
+import { formatApiError } from "../../utils/errors.js";
+import { getStoreCode } from "../../config.js";
+// Core CRUD handlers
+export async function campaignList(input) {
+    const storeCode = getStoreCode(input.storeCode);
+    const params = new URLSearchParams();
+    if (input.page)
+        params.append("_page", String(input.page));
+    if (input.perPage)
+        params.append("_itemsOnPage", String(input.perPage));
+    if (input.active !== undefined)
+        params.append("active", String(input.active));
+    if (input.type)
+        params.append("type", input.type);
+    if (input.trigger)
+        params.append("trigger", input.trigger);
+    const queryString = params.toString();
+    const url = `/${storeCode}/campaign${queryString ? `?${queryString}` : ""}`;
+    try {
+        const response = await apiGet(url);
+        const campaigns = (response.items || []).map((item) => {
+            const campaign = item;
+            const translations = campaign.translations;
+            let name = "";
+            if (Array.isArray(translations)) {
+                const enTranslation = translations.find((t) => t.locale === "en" || t.locale?.startsWith("en"));
+                name = enTranslation?.name || translations[0]?.name || campaign.name || "";
+            }
+            else if (translations && typeof translations === "object") {
+                name = translations.en?.name || campaign.name || "";
+            }
+            else {
+                name = campaign.name || "";
+            }
+            return {
+                campaignId: campaign.campaignId,
+                name,
+                type: campaign.type,
+                trigger: campaign.trigger,
+                active: (campaign.active ?? false),
+                displayOrder: campaign.displayOrder,
+            };
+        });
+        const total = response.total || {};
+        return {
+            campaigns,
+            total: {
+                all: typeof total.all === "number" ? total.all : undefined,
+                filtered: typeof total.filtered === "number" ? total.filtered : undefined,
+            },
+        };
+    }
+    catch (error) {
+        throw formatApiError(error, "ol_campaign_list");
+    }
+}
+export async function campaignGet(input) {
+    const storeCode = getStoreCode(input.storeCode);
+    try {
+        const response = await apiGet(`/${storeCode}/campaign/${input.campaignId}`);
+        return response;
+    }
+    catch (error) {
+        throw formatApiError(error, "ol_campaign_get");
+    }
+}
+export async function campaignCreate(input) {
+    const storeCode = getStoreCode(input.storeCode);
+    const campaignPayload = {
+        type: input.type,
+        trigger: input.trigger,
+        translations: input.translations,
+        activity: input.activity,
+        rules: input.rules,
+    };
+    if (input.visibility)
+        campaignPayload.visibility = input.visibility;
+    if (input.audience)
+        campaignPayload.audience = input.audience;
+    if (input.limits)
+        campaignPayload.limits = input.limits;
+    if (input.active !== undefined)
+        campaignPayload.active = input.active;
+    if (input.displayOrder !== undefined)
+        campaignPayload.displayOrder = input.displayOrder;
+    if (input.labels)
+        campaignPayload.labels = input.labels;
+    if (input.event)
+        campaignPayload.event = input.event;
+    if (input.achievementId)
+        campaignPayload.achievementId = input.achievementId;
+    try {
+        const response = await apiPost(`/${storeCode}/campaign`, { campaign: campaignPayload });
+        return { campaignId: response.campaignId };
+    }
+    catch (error) {
+        throw formatApiError(error, "ol_campaign_create");
+    }
+}
+export async function campaignUpdate(input) {
+    const storeCode = getStoreCode(input.storeCode);
+    const campaignId = input.campaignId;
+    const { storeCode: _sc, campaignId: _cid, ...campaignPayload } = input;
+    try {
+        await apiPut(`/${storeCode}/campaign/${campaignId}`, { campaign: campaignPayload });
+    }
+    catch (error) {
+        throw formatApiError(error, "ol_campaign_update");
+    }
+}
+export async function campaignPatch(input) {
+    const storeCode = getStoreCode(input.storeCode);
+    const patchPayload = {};
+    if (input.active !== undefined)
+        patchPayload.active = input.active;
+    if (input.displayOrder !== undefined)
+        patchPayload.displayOrder = input.displayOrder;
+    try {
+        await apiPatch(`/${storeCode}/campaign/${input.campaignId}`, { campaign: patchPayload });
+    }
+    catch (error) {
+        throw formatApiError(error, "ol_campaign_patch");
+    }
+}
+export async function campaignDelete(input) {
+    const storeCode = getStoreCode(input.storeCode);
+    try {
+        await apiDelete(`/${storeCode}/campaign/${input.campaignId}`);
+    }
+    catch (error) {
+        throw formatApiError(error, "ol_campaign_delete");
+    }
+}
+// Simulation handler
+export async function campaignSimulate(input) {
+    const storeCode = getStoreCode(input.storeCode);
+    const simulatePayload = {
+        trigger: input.trigger,
+        customer: {},
+    };
+    const customer = {};
+    if (input.customer.customerId)
+        customer.id = input.customer.customerId;
+    if (input.customer.id)
+        customer.id = input.customer.id;
+    if (input.customer.email)
+        customer.email = input.customer.email;
+    if (input.customer.loyaltyCardNumber)
+        customer.loyaltyCardNumber = input.customer.loyaltyCardNumber;
+    if (input.customer.phone)
+        customer.phone = input.customer.phone;
+    if (input.customer.firstName)
+        customer.firstName = input.customer.firstName;
+    if (input.customer.lastName)
+        customer.lastName = input.customer.lastName;
+    simulatePayload.customer = customer;
+    if (input.transaction) {
+        const transaction = {};
+        if (input.transaction.grossValue !== undefined)
+            transaction.grossValue = input.transaction.grossValue;
+        if (input.transaction.documentNumber)
+            transaction.documentNumber = input.transaction.documentNumber;
+        if (input.transaction.purchasedAt)
+            transaction.purchasedAt = input.transaction.purchasedAt;
+        if (input.transaction.documentType)
+            transaction.documentType = input.transaction.documentType;
+        if (input.transaction.purchasePlace)
+            transaction.purchasePlace = input.transaction.purchasePlace;
+        if (input.transaction.items)
+            transaction.items = input.transaction.items;
+        if (input.transaction.labels)
+            transaction.labels = input.transaction.labels;
+        simulatePayload.transaction = transaction;
+    }
+    if (input.customEvent) {
+        simulatePayload.event = input.customEvent.eventCode;
+        if (input.customEvent.attributes) {
+            simulatePayload.eventAttributes = input.customEvent.attributes;
+        }
+    }
+    if (input.referrer) {
+        const referrer = {};
+        if (input.referrer.id)
+            referrer.id = input.referrer.id;
+        if (input.referrer.email)
+            referrer.email = input.referrer.email;
+        if (input.referrer.loyaltyCardNumber)
+            referrer.loyaltyCardNumber = input.referrer.loyaltyCardNumber;
+        simulatePayload.referrer = referrer;
+    }
+    try {
+        const response = await apiPost(`/${storeCode}/campaign/simulate`, { simulate: simulatePayload });
+        const effectsByCampaign = new Map();
+        for (const effect of response.effects || []) {
+            const campaignId = effect.campaign?.campaignId || "unknown";
+            const campaignName = effect.campaign?.name || undefined;
+            if (!effectsByCampaign.has(campaignId)) {
+                effectsByCampaign.set(campaignId, {
+                    campaignId,
+                    campaignName,
+                    effects: [],
+                });
+            }
+            const campaignEffect = effectsByCampaign.get(campaignId);
+            campaignEffect.effects.push({
+                type: effect.type,
+                target: effect.target,
+                points: effect.points,
+                wallet: effect.wallet,
+                rewardId: effect.rewardId,
+            });
+        }
+        return {
+            simulatedEffects: Array.from(effectsByCampaign.values()),
+            evaluationWarnings: response.evaluationWarnings,
+            simulatedMember: response.simulatedMember,
+        };
+    }
+    catch (error) {
+        throw formatApiError(error, "ol_campaign_simulate");
+    }
+}