@open-loyalty/mcp-server 1.0.0

package/dist/tools/audit.js

@@ -0,0 +1,90 @@
+import { z } from "zod";
+import { apiGet, apiPost } from "../client/http.js";
+import { formatApiError } from "../utils/errors.js";
+// Input Schemas
+export const AuditListInputSchema = {
+    page: z.number().optional().describe("Page number (default: 1)."),
+    perPage: z.number().optional().describe("Items per page (default: 25)."),
+    eventType: z.string().optional().describe("Filter by event type."),
+    entityId: z.string().optional().describe("Filter by entity ID."),
+    entityType: z.string().optional().describe("Filter by entity type (e.g., MEMBER, CAMPAIGN)."),
+    username: z.string().optional().describe("Filter by username who performed the action."),
+    dateFrom: z.string().optional().describe("Filter by creation date from (ISO format)."),
+    dateTo: z.string().optional().describe("Filter by creation date to (ISO format)."),
+    store: z.string().optional().describe("Filter by store code."),
+};
+export const AuditExportInputSchema = {
+    dateFrom: z.string().optional().describe("Export logs from this date (ISO format)."),
+    dateTo: z.string().optional().describe("Export logs to this date (ISO format)."),
+    page: z.number().optional().describe("Page number for export."),
+    perPage: z.number().optional().describe("Items per page for export."),
+};
+// Handler functions
+export async function auditList(input) {
+    const params = new URLSearchParams();
+    if (input.page)
+        params.append("_page", String(input.page));
+    if (input.perPage)
+        params.append("_itemsOnPage", String(input.perPage));
+    if (input.eventType)
+        params.append("eventType", input.eventType);
+    if (input.entityId)
+        params.append("entityId", input.entityId);
+    if (input.entityType)
+        params.append("entityType", input.entityType);
+    if (input.username)
+        params.append("username", input.username);
+    if (input.dateFrom)
+        params.append("createdAt[gte]", input.dateFrom);
+    if (input.dateTo)
+        params.append("createdAt[lte]", input.dateTo);
+    if (input.store)
+        params.append("store", input.store);
+    const queryString = params.toString();
+    const url = `/audit/log${queryString ? `?${queryString}` : ""}`;
+    try {
+        const response = await apiGet(url);
+        return response;
+    }
+    catch (error) {
+        throw formatApiError(error, "openloyalty_audit_list");
+    }
+}
+export async function auditExport(input) {
+    const payload = {};
+    const systemLogPayload = {};
+    if (input.dateFrom || input.dateTo) {
+        systemLogPayload.createdAt = {};
+        if (input.dateFrom)
+            systemLogPayload.createdAt.gte = input.dateFrom;
+        if (input.dateTo)
+            systemLogPayload.createdAt.lte = input.dateTo;
+    }
+    if (input.page)
+        systemLogPayload._page = input.page;
+    if (input.perPage)
+        systemLogPayload._itemsOnPage = input.perPage;
+    payload.systemLog = systemLogPayload;
+    try {
+        const response = await apiPost("/system-log/export", payload);
+        return response;
+    }
+    catch (error) {
+        throw formatApiError(error, "openloyalty_audit_export");
+    }
+}
+// Tool definitions
+export const auditToolDefinitions = [
+    {
+        name: "openloyalty_audit_list",
+        description: "List audit log entries with optional filtering. Returns paginated list of audit entries with auditLogId, eventType, entityType, entityId, username, timestamp, and details. Audit logs track all administrative actions. Use for compliance and troubleshooting.",
+        inputSchema: AuditListInputSchema,
+        handler: auditList,
+    },
+    {
+        name: "openloyalty_audit_export",
+        description: "Create an export of system logs. Returns exportId that can be used to track export status. The export will be processed asynchronously. Use date filters to scope the export range.",
+        inputSchema: AuditExportInputSchema,
+        handler: auditExport,
+    },
+];

package/dist/tools/badge.d.ts

@@ -0,0 +1,135 @@
+import { z } from "zod";
+import { BadgeTypeListItem, MemberBadge } from "../types/schemas/badge.js";
+export declare const BadgeListInputSchema: {
+    storeCode: z.ZodOptional<z.ZodString>;
+    page: z.ZodOptional<z.ZodNumber>;
+    perPage: z.ZodOptional<z.ZodNumber>;
+    name: z.ZodOptional<z.ZodString>;
+    badgeTypeId: z.ZodOptional<z.ZodString>;
+};
+export declare const BadgeGetInputSchema: {
+    storeCode: z.ZodOptional<z.ZodString>;
+    badgeTypeId: z.ZodString;
+};
+export declare const BadgeUpdateInputSchema: {
+    storeCode: z.ZodOptional<z.ZodString>;
+    badgeTypeId: z.ZodString;
+    name: z.ZodOptional<z.ZodString>;
+    translations: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+        name: z.ZodString;
+        description: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        name: string;
+        description?: string | undefined;
+    }, {
+        name: string;
+        description?: string | undefined;
+    }>>>;
+    imageUrl: z.ZodOptional<z.ZodString>;
+    active: z.ZodOptional<z.ZodBoolean>;
+};
+export declare const BadgeGetMemberBadgesInputSchema: {
+    storeCode: z.ZodOptional<z.ZodString>;
+    memberId: z.ZodString;
+    page: z.ZodOptional<z.ZodNumber>;
+    perPage: z.ZodOptional<z.ZodNumber>;
+    name: z.ZodOptional<z.ZodString>;
+    badgeTypeId: z.ZodOptional<z.ZodString>;
+};
+export declare function badgeList(input: {
+    storeCode?: string;
+    page?: number;
+    perPage?: number;
+    name?: string;
+    badgeTypeId?: string;
+}): Promise<{
+    badges: BadgeTypeListItem[];
+    total: {
+        all?: number;
+        filtered?: number;
+    };
+}>;
+export declare function badgeGet(input: {
+    storeCode?: string;
+    badgeTypeId: string;
+}): Promise<Record<string, unknown>>;
+interface BadgeUpdateInput {
+    storeCode?: string;
+    badgeTypeId: string;
+    name?: string;
+    translations?: Record<string, {
+        name: string;
+        description?: string;
+    }>;
+    imageUrl?: string;
+    active?: boolean;
+}
+export declare function badgeUpdate(input: BadgeUpdateInput): Promise<void>;
+export declare function badgeGetMemberBadges(input: {
+    storeCode?: string;
+    memberId: string;
+    page?: number;
+    perPage?: number;
+    name?: string;
+    badgeTypeId?: string;
+}): Promise<{
+    badges: MemberBadge[];
+    total: {
+        all?: number;
+        filtered?: number;
+    };
+}>;
+export declare const badgeToolDefinitions: readonly [{
+    readonly name: "openloyalty_badge_list";
+    readonly description: "List badge types. Badges are visual rewards linked to achievements. When a member completes an achievement with a badgeTypeId, they earn that badge. Use for displaying available badges.";
+    readonly inputSchema: {
+        storeCode: z.ZodOptional<z.ZodString>;
+        page: z.ZodOptional<z.ZodNumber>;
+        perPage: z.ZodOptional<z.ZodNumber>;
+        name: z.ZodOptional<z.ZodString>;
+        badgeTypeId: z.ZodOptional<z.ZodString>;
+    };
+    readonly handler: typeof badgeList;
+}, {
+    readonly name: "openloyalty_badge_get";
+    readonly description: "Get badge type details including name, image URL, and linked achievements count.";
+    readonly inputSchema: {
+        storeCode: z.ZodOptional<z.ZodString>;
+        badgeTypeId: z.ZodString;
+    };
+    readonly handler: typeof badgeGet;
+}, {
+    readonly name: "openloyalty_badge_update";
+    readonly description: "Update badge type configuration. Badge types are created automatically when referenced by achievements. Use this to update name, image, or translations.";
+    readonly inputSchema: {
+        storeCode: z.ZodOptional<z.ZodString>;
+        badgeTypeId: z.ZodString;
+        name: z.ZodOptional<z.ZodString>;
+        translations: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+            name: z.ZodString;
+            description: z.ZodOptional<z.ZodString>;
+        }, "strip", z.ZodTypeAny, {
+            name: string;
+            description?: string | undefined;
+        }, {
+            name: string;
+            description?: string | undefined;
+        }>>>;
+        imageUrl: z.ZodOptional<z.ZodString>;
+        active: z.ZodOptional<z.ZodBoolean>;
+    };
+    readonly handler: typeof badgeUpdate;
+}, {
+    readonly name: "openloyalty_badge_get_member_badges";
+    readonly description: "Get badges earned by a member. Returns each badge with completedCount showing how many times it was earned. Use for displaying member's badge collection.";
+    readonly inputSchema: {
+        storeCode: z.ZodOptional<z.ZodString>;
+        memberId: z.ZodString;
+        page: z.ZodOptional<z.ZodNumber>;
+        perPage: z.ZodOptional<z.ZodNumber>;
+        name: z.ZodOptional<z.ZodString>;
+        badgeTypeId: z.ZodOptional<z.ZodString>;
+    };
+    readonly handler: typeof badgeGetMemberBadges;
+}];
+export {};

package/dist/tools/badge.js

@@ -0,0 +1,165 @@
+import { z } from "zod";
+import { apiGet, apiPut } from "../client/http.js";
+import { formatApiError } from "../utils/errors.js";
+import { getConfig } from "../config.js";
+// Input Schemas
+export const BadgeListInputSchema = {
+    storeCode: z.string().optional().describe("Store code. If not provided, uses the default store code from configuration."),
+    page: z.number().optional().describe("Page number (default: 1)."),
+    perPage: z.number().optional().describe("Items per page (default: 10)."),
+    name: z.string().optional().describe("Filter by badge name."),
+    badgeTypeId: z.string().optional().describe("Filter by specific badge type ID."),
+};
+export const BadgeGetInputSchema = {
+    storeCode: z.string().optional().describe("Store code. If not provided, uses the default store code from configuration."),
+    badgeTypeId: z.string().describe("The badge type ID (UUID) to retrieve."),
+};
+export const BadgeUpdateInputSchema = {
+    storeCode: z.string().optional().describe("Store code. If not provided, uses the default store code from configuration."),
+    badgeTypeId: z.string().describe("The badge type ID (UUID) to update."),
+    name: z.string().optional().describe("Badge name."),
+    translations: z.record(z.string(), z.object({
+        name: z.string(),
+        description: z.string().optional(),
+    })).optional().describe("Badge translations."),
+    imageUrl: z.string().optional().describe("URL to badge image."),
+    active: z.boolean().optional().describe("Whether badge type is active."),
+};
+export const BadgeGetMemberBadgesInputSchema = {
+    storeCode: z.string().optional().describe("Store code. If not provided, uses the default store code from configuration."),
+    memberId: z.string().describe("The member ID (UUID)."),
+    page: z.number().optional().describe("Page number (default: 1)."),
+    perPage: z.number().optional().describe("Items per page (default: 10)."),
+    name: z.string().optional().describe("Filter by badge name."),
+    badgeTypeId: z.string().optional().describe("Filter by specific badge type ID."),
+};
+// Handler functions
+export async function badgeList(input) {
+    const config = getConfig();
+    const storeCode = input.storeCode || config.defaultStoreCode;
+    const params = new URLSearchParams();
+    if (input.page)
+        params.append("_page", String(input.page));
+    if (input.perPage)
+        params.append("_itemsOnPage", String(input.perPage));
+    if (input.name)
+        params.append("name", input.name);
+    if (input.badgeTypeId)
+        params.append("badgeTypeId", input.badgeTypeId);
+    const queryString = params.toString();
+    const url = `/${storeCode}/badge-type${queryString ? `?${queryString}` : ""}`;
+    try {
+        const response = await apiGet(url);
+        const badges = (response.items || []).map((item) => ({
+            badgeTypeId: item.badgeTypeId,
+            name: item.name,
+            createdAt: item.createdAt,
+            updatedAt: item.updatedAt,
+        }));
+        const total = response.total || {};
+        return {
+            badges,
+            total: {
+                all: typeof total.all === "number" ? total.all : undefined,
+                filtered: typeof total.filtered === "number" ? total.filtered : undefined,
+            },
+        };
+    }
+    catch (error) {
+        throw formatApiError(error, "openloyalty_badge_list");
+    }
+}
+export async function badgeGet(input) {
+    const config = getConfig();
+    const storeCode = input.storeCode || config.defaultStoreCode;
+    try {
+        const response = await apiGet(`/${storeCode}/badge-type/${input.badgeTypeId}`);
+        return response;
+    }
+    catch (error) {
+        throw formatApiError(error, "openloyalty_badge_get");
+    }
+}
+export async function badgeUpdate(input) {
+    const config = getConfig();
+    const storeCode = input.storeCode || config.defaultStoreCode;
+    const badgePayload = {};
+    if (input.name !== undefined)
+        badgePayload.name = input.name;
+    if (input.translations)
+        badgePayload.translations = input.translations;
+    if (input.imageUrl !== undefined)
+        badgePayload.imageUrl = input.imageUrl;
+    if (input.active !== undefined)
+        badgePayload.active = input.active;
+    try {
+        // CRITICAL: Wrap body as { badgeType: {...} }
+        await apiPut(`/${storeCode}/badge-type/${input.badgeTypeId}`, { badgeType: badgePayload });
+    }
+    catch (error) {
+        throw formatApiError(error, "openloyalty_badge_update");
+    }
+}
+export async function badgeGetMemberBadges(input) {
+    const config = getConfig();
+    const storeCode = input.storeCode || config.defaultStoreCode;
+    const params = new URLSearchParams();
+    if (input.page)
+        params.append("_page", String(input.page));
+    if (input.perPage)
+        params.append("_itemsOnPage", String(input.perPage));
+    if (input.name)
+        params.append("name", input.name);
+    if (input.badgeTypeId)
+        params.append("badgeTypeId", input.badgeTypeId);
+    const queryString = params.toString();
+    const url = `/${storeCode}/member/${input.memberId}/badge${queryString ? `?${queryString}` : ""}`;
+    try {
+        const response = await apiGet(url);
+        const badges = (response.items || []).map((item) => ({
+            badgeTypeId: item.badgeTypeId,
+            name: item.name,
+            completedCount: item.completedCount,
+            createdAt: item.createdAt,
+            updatedAt: item.updatedAt,
+        }));
+        const total = response.total || {};
+        return {
+            badges,
+            total: {
+                all: typeof total.all === "number" ? total.all : undefined,
+                filtered: typeof total.filtered === "number" ? total.filtered : undefined,
+            },
+        };
+    }
+    catch (error) {
+        throw formatApiError(error, "openloyalty_badge_get_member_badges");
+    }
+}
+// Tool definitions
+export const badgeToolDefinitions = [
+    {
+        name: "openloyalty_badge_list",
+        description: "List badge types. Badges are visual rewards linked to achievements. When a member completes an achievement with a badgeTypeId, they earn that badge. Use for displaying available badges.",
+        inputSchema: BadgeListInputSchema,
+        handler: badgeList,
+    },
+    {
+        name: "openloyalty_badge_get",
+        description: "Get badge type details including name, image URL, and linked achievements count.",
+        inputSchema: BadgeGetInputSchema,
+        handler: badgeGet,
+    },
+    {
+        name: "openloyalty_badge_update",
+        description: "Update badge type configuration. Badge types are created automatically when referenced by achievements. Use this to update name, image, or translations.",
+        inputSchema: BadgeUpdateInputSchema,
+        handler: badgeUpdate,
+    },
+    {
+        name: "openloyalty_badge_get_member_badges",
+        description: "Get badges earned by a member. Returns each badge with completedCount showing how many times it was earned. Use for displaying member's badge collection.",
+        inputSchema: BadgeGetMemberBadgesInputSchema,
+        handler: badgeGetMemberBadges,
+    },
+];