@open-loyalty/mcp-server 1.0.0

package/dist/tools/reward.test.js

@@ -0,0 +1,240 @@
+// src/tools/reward.test.ts
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { setupMockAxios, teardownMockAxios, getMockAxios } from '../../tests/mocks/http.mock.js';
+import { rewardFixtures } from '../../tests/fixtures/reward.fixtures.js';
+import { rewardList, rewardCreate, rewardGet, rewardUpdate, rewardActivate, rewardDeactivate, rewardBuy, rewardRedeem, rewardCategoryList, } from './reward.js';
+describe('Reward Operations', () => {
+    beforeEach(() => {
+        setupMockAxios();
+    });
+    afterEach(() => {
+        teardownMockAxios();
+    });
+    describe('rewardList', () => {
+        it('should list rewards and map items correctly', async () => {
+            const mockAxios = getMockAxios();
+            mockAxios.onGet('/default/reward').reply(200, rewardFixtures.listResponse);
+            const result = await rewardList({});
+            expect(result.rewards).toHaveLength(2);
+            expect(result.rewards[0].rewardId).toBe('reward-uuid-1');
+            expect(result.rewards[0].name).toBe('Discount Coupon');
+            expect(result.rewards[0].type).toBe('static_coupon');
+            expect(result.rewards[0].costInPoints).toBe(100);
+            expect(result.total.all).toBe(10);
+            expect(result.total.filtered).toBe(2);
+        });
+        it('should include pagination params', async () => {
+            const mockAxios = getMockAxios();
+            mockAxios.onGet(/\/default\/reward/).reply(200, rewardFixtures.listResponse);
+            await rewardList({ page: 2, perPage: 25 });
+            const url = mockAxios.history.get[0].url;
+            expect(url).toContain('_page=2');
+            expect(url).toContain('_itemsOnPage=25');
+        });
+        it('should include filter params', async () => {
+            const mockAxios = getMockAxios();
+            mockAxios.onGet(/\/default\/reward/).reply(200, rewardFixtures.listResponse);
+            await rewardList({
+                active: true,
+                type: 'static_coupon',
+                categoryId: 'cat-uuid',
+            });
+            const url = mockAxios.history.get[0].url;
+            expect(url).toContain('active=true');
+            expect(url).toContain('reward=static_coupon');
+            expect(url).toContain('categoryId=cat-uuid');
+        });
+    });
+    describe('rewardCreate', () => {
+        it('should create reward with reward wrapper', async () => {
+            const mockAxios = getMockAxios();
+            mockAxios.onPost('/default/reward').reply(200, rewardFixtures.createResponse);
+            const result = await rewardCreate({
+                name: 'Test Reward',
+                type: 'static_coupon',
+                costInPoints: 100,
+            });
+            expect(result.rewardId).toBe('reward-uuid-123');
+            expect(result.name).toBe('Test Reward');
+            expect(result.costInPoints).toBe(100);
+            // Verify request body format with reward wrapper
+            const requestData = JSON.parse(mockAxios.history.post[0].data);
+            expect(requestData.reward).toBeDefined();
+            expect(requestData.reward.name).toBe('Test Reward');
+            expect(requestData.reward.type).toBe('static_coupon');
+            expect(requestData.reward.costInPoints).toBe(100);
+        });
+        it('should include optional fields', async () => {
+            const mockAxios = getMockAxios();
+            mockAxios.onPost('/default/reward').reply(200, rewardFixtures.createResponse);
+            await rewardCreate({
+                name: 'Full Reward',
+                type: 'static_coupon',
+                costInPoints: 200,
+                description: 'A test reward',
+                couponValue: 10,
+                couponValueType: 'Money',
+                daysValid: 30,
+                active: true,
+                categories: ['cat-1', 'cat-2'],
+                levels: ['level-1'],
+                target: 'level',
+            });
+            const requestData = JSON.parse(mockAxios.history.post[0].data);
+            expect(requestData.reward.description).toBe('A test reward');
+            expect(requestData.reward.couponValue).toBe(10);
+            expect(requestData.reward.couponValueType).toBe('Money');
+            expect(requestData.reward.daysValid).toBe(30);
+            expect(requestData.reward.categories).toEqual(['cat-1', 'cat-2']);
+            expect(requestData.reward.target).toBe('level');
+        });
+    });
+    describe('rewardGet', () => {
+        it('should get reward details', async () => {
+            const mockAxios = getMockAxios();
+            mockAxios.onGet('/default/reward/reward-uuid').reply(200, rewardFixtures.getResponse);
+            const result = await rewardGet({ rewardId: 'reward-uuid' });
+            expect(result.rewardId).toBe('reward-uuid-123');
+            expect(result.name).toBe('Test Reward');
+            expect(result.type).toBe('static_coupon');
+            expect(result.costInPoints).toBe(100);
+            expect(result.active).toBe(true);
+        });
+    });
+    describe('rewardUpdate', () => {
+        it('should update reward with reward wrapper', async () => {
+            const mockAxios = getMockAxios();
+            mockAxios.onPut('/default/reward/reward-uuid').reply(200);
+            await rewardUpdate({
+                rewardId: 'reward-uuid',
+                name: 'Updated Reward',
+                costInPoints: 150,
+            });
+            const requestData = JSON.parse(mockAxios.history.put[0].data);
+            expect(requestData.reward).toBeDefined();
+            expect(requestData.reward.name).toBe('Updated Reward');
+            expect(requestData.reward.costInPoints).toBe(150);
+        });
+        it('should include optional arrays', async () => {
+            const mockAxios = getMockAxios();
+            mockAxios.onPut('/default/reward/reward-uuid').reply(200);
+            await rewardUpdate({
+                rewardId: 'reward-uuid',
+                categories: ['cat-1'],
+                levels: ['level-1', 'level-2'],
+                segments: ['segment-1'],
+            });
+            const requestData = JSON.parse(mockAxios.history.put[0].data);
+            expect(requestData.reward.categories).toEqual(['cat-1']);
+            expect(requestData.reward.levels).toEqual(['level-1', 'level-2']);
+            expect(requestData.reward.segments).toEqual(['segment-1']);
+        });
+    });
+    describe('rewardActivate', () => {
+        it('should call activate endpoint', async () => {
+            const mockAxios = getMockAxios();
+            mockAxios.onPost('/default/reward/reward-uuid/activate').reply(200);
+            await rewardActivate({ rewardId: 'reward-uuid' });
+            expect(mockAxios.history.post[0].url).toBe('/default/reward/reward-uuid/activate');
+        });
+    });
+    describe('rewardDeactivate', () => {
+        it('should call deactivate endpoint', async () => {
+            const mockAxios = getMockAxios();
+            mockAxios.onPost('/default/reward/reward-uuid/deactivate').reply(200);
+            await rewardDeactivate({ rewardId: 'reward-uuid' });
+            expect(mockAxios.history.post[0].url).toBe('/default/reward/reward-uuid/deactivate');
+        });
+    });
+    describe('rewardBuy', () => {
+        it('should buy reward and return first issued', async () => {
+            const mockAxios = getMockAxios();
+            mockAxios.onPost('/default/reward/reward-uuid/buy').reply(200, rewardFixtures.buyResponse);
+            const result = await rewardBuy({
+                rewardId: 'reward-uuid',
+                memberId: 'member-uuid',
+            });
+            expect(result.issuedRewardId).toBe('issued-uuid-123');
+            expect(result.couponCode).toBe('COUPON-ABC123');
+            const requestData = JSON.parse(mockAxios.history.post[0].data);
+            expect(requestData.customerId).toBe('member-uuid');
+        });
+        it('should include optional parameters', async () => {
+            const mockAxios = getMockAxios();
+            mockAxios.onPost('/default/reward/reward-uuid/buy').reply(200, rewardFixtures.buyResponse);
+            await rewardBuy({
+                rewardId: 'reward-uuid',
+                memberId: 'member-uuid',
+                quantity: 3,
+                couponValue: 50,
+                withoutPoints: true,
+            });
+            const requestData = JSON.parse(mockAxios.history.post[0].data);
+            expect(requestData.quantity).toBe(3);
+            expect(requestData.couponValue).toBe(50);
+            expect(requestData.withoutPoints).toBe(true);
+        });
+        it('should throw error for insufficient points', async () => {
+            const mockAxios = getMockAxios();
+            mockAxios.onPost('/default/reward/reward-uuid/buy').reply(400, {
+                message: 'NotEnoughPoints',
+            });
+            // API returns 400 error which gets thrown
+            await expect(rewardBuy({
+                rewardId: 'reward-uuid',
+                memberId: 'member-uuid',
+            })).rejects.toThrow();
+        });
+    });
+    describe('rewardRedeem', () => {
+        it('should redeem coupon', async () => {
+            const mockAxios = getMockAxios();
+            mockAxios.onPost('/default/member/member-uuid/reward/redeem').reply(200, rewardFixtures.redeemResponse);
+            const result = await rewardRedeem({
+                memberId: 'member-uuid',
+                couponCode: 'COUPON-ABC123',
+            });
+            expect(result.code).toBe('COUPON-ABC123');
+            expect(result.used).toBe(true);
+            const requestData = JSON.parse(mockAxios.history.post[0].data);
+            expect(requestData.couponCode).toBe('COUPON-ABC123');
+        });
+        it('should throw error for non-existent coupon', async () => {
+            const mockAxios = getMockAxios();
+            mockAxios.onPost('/default/member/member-uuid/reward/redeem').reply(400, {
+                message: 'CouponDoesNotExist',
+            });
+            // API returns 400 error which gets thrown
+            await expect(rewardRedeem({
+                memberId: 'member-uuid',
+                couponCode: 'INVALID-CODE',
+            })).rejects.toThrow();
+        });
+    });
+    describe('rewardCategoryList', () => {
+        it('should list categories and map rewardCategoryId to categoryId', async () => {
+            const mockAxios = getMockAxios();
+            mockAxios.onGet('/default/rewardCategory').reply(200, rewardFixtures.categoryListResponse);
+            const result = await rewardCategoryList({});
+            expect(result.categories).toHaveLength(2);
+            expect(result.categories[0].categoryId).toBe('cat-uuid-1');
+            expect(result.categories[0].name).toBe('Discounts');
+            expect(result.categories[0].active).toBe(true);
+        });
+        it('should include pagination params', async () => {
+            const mockAxios = getMockAxios();
+            mockAxios.onGet(/\/default\/rewardCategory/).reply(200, rewardFixtures.categoryListResponse);
+            await rewardCategoryList({ page: 2, perPage: 10 });
+            const url = mockAxios.history.get[0].url;
+            expect(url).toContain('_page=2');
+            expect(url).toContain('_itemsOnPage=10');
+        });
+        it('should filter by active status', async () => {
+            const mockAxios = getMockAxios();
+            mockAxios.onGet(/\/default\/rewardCategory/).reply(200, rewardFixtures.categoryListResponse);
+            await rewardCategoryList({ active: true });
+            const url = mockAxios.history.get[0].url;
+            expect(url).toContain('active=true');
+        });
+    });
+});

package/dist/tools/role.d.ts

@@ -0,0 +1,161 @@
+import { z } from "zod";
+import { Role, RoleListItem, ACLResource, RolePermissionInput } from "../types/schemas/role.js";
+export declare const RoleListInputSchema: {
+    page: z.ZodOptional<z.ZodNumber>;
+    perPage: z.ZodOptional<z.ZodNumber>;
+    name: z.ZodOptional<z.ZodString>;
+    master: z.ZodOptional<z.ZodBoolean>;
+    default: z.ZodOptional<z.ZodBoolean>;
+};
+export declare const RoleCreateInputSchema: {
+    name: z.ZodString;
+    permissions: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        resource: z.ZodString;
+        access: z.ZodString;
+        filterQuery: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        resource: string;
+        access: string;
+        filterQuery?: string | undefined;
+    }, {
+        resource: string;
+        access: string;
+        filterQuery?: string | undefined;
+    }>, "many">>;
+    stores: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    default: z.ZodOptional<z.ZodBoolean>;
+};
+export declare const RoleGetInputSchema: {
+    roleId: z.ZodUnion<[z.ZodString, z.ZodNumber]>;
+};
+export declare const RoleUpdateInputSchema: {
+    roleId: z.ZodUnion<[z.ZodString, z.ZodNumber]>;
+    name: z.ZodOptional<z.ZodString>;
+    permissions: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        resource: z.ZodString;
+        access: z.ZodString;
+        filterQuery: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        resource: string;
+        access: string;
+        filterQuery?: string | undefined;
+    }, {
+        resource: string;
+        access: string;
+        filterQuery?: string | undefined;
+    }>, "many">>;
+    stores: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    default: z.ZodOptional<z.ZodBoolean>;
+};
+export declare const RoleDeleteInputSchema: {
+    roleId: z.ZodUnion<[z.ZodString, z.ZodNumber]>;
+};
+export declare function roleList(input: {
+    page?: number;
+    perPage?: number;
+    name?: string;
+    master?: boolean;
+    default?: boolean;
+}): Promise<{
+    items: RoleListItem[];
+    total?: Record<string, unknown>;
+}>;
+export declare function roleCreate(input: {
+    name: string;
+    permissions?: RolePermissionInput[];
+    stores?: string[];
+    default?: boolean;
+}): Promise<void>;
+export declare function roleGet(input: {
+    roleId: string | number;
+}): Promise<Role>;
+export declare function roleUpdate(input: {
+    roleId: string | number;
+    name?: string;
+    permissions?: RolePermissionInput[];
+    stores?: string[];
+    default?: boolean;
+}): Promise<void>;
+export declare function roleDelete(input: {
+    roleId: string | number;
+}): Promise<void>;
+export declare function aclGetResources(): Promise<{
+    items: ACLResource[];
+    total?: Record<string, unknown>;
+}>;
+export declare const roleToolDefinitions: readonly [{
+    readonly name: "openloyalty_role_list";
+    readonly description: "List all roles with optional filtering. Returns paginated list of roles with id, name, permissions, master status, and default status.";
+    readonly inputSchema: {
+        page: z.ZodOptional<z.ZodNumber>;
+        perPage: z.ZodOptional<z.ZodNumber>;
+        name: z.ZodOptional<z.ZodString>;
+        master: z.ZodOptional<z.ZodBoolean>;
+        default: z.ZodOptional<z.ZodBoolean>;
+    };
+    readonly handler: typeof roleList;
+}, {
+    readonly name: "openloyalty_role_create";
+    readonly description: "Create a new role with permissions. Requires name. Optionally specify permissions (array of {resource, access, filterQuery}) and stores. Returns void on success (201 Created).";
+    readonly inputSchema: {
+        name: z.ZodString;
+        permissions: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            resource: z.ZodString;
+            access: z.ZodString;
+            filterQuery: z.ZodOptional<z.ZodString>;
+        }, "strip", z.ZodTypeAny, {
+            resource: string;
+            access: string;
+            filterQuery?: string | undefined;
+        }, {
+            resource: string;
+            access: string;
+            filterQuery?: string | undefined;
+        }>, "many">>;
+        stores: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        default: z.ZodOptional<z.ZodBoolean>;
+    };
+    readonly handler: typeof roleCreate;
+}, {
+    readonly name: "openloyalty_role_get";
+    readonly description: "Get full role details by ID. Returns role with name, permissions array, master status, default status, and stores.";
+    readonly inputSchema: {
+        roleId: z.ZodUnion<[z.ZodString, z.ZodNumber]>;
+    };
+    readonly handler: typeof roleGet;
+}, {
+    readonly name: "openloyalty_role_update";
+    readonly description: "Update a role's name, permissions, or stores. Returns void on success (204 No Content).";
+    readonly inputSchema: {
+        roleId: z.ZodUnion<[z.ZodString, z.ZodNumber]>;
+        name: z.ZodOptional<z.ZodString>;
+        permissions: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            resource: z.ZodString;
+            access: z.ZodString;
+            filterQuery: z.ZodOptional<z.ZodString>;
+        }, "strip", z.ZodTypeAny, {
+            resource: string;
+            access: string;
+            filterQuery?: string | undefined;
+        }, {
+            resource: string;
+            access: string;
+            filterQuery?: string | undefined;
+        }>, "many">>;
+        stores: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        default: z.ZodOptional<z.ZodBoolean>;
+    };
+    readonly handler: typeof roleUpdate;
+}, {
+    readonly name: "openloyalty_role_delete";
+    readonly description: "Delete a role by ID. Returns void on success (204 No Content). Cannot delete roles that are assigned to admin users.";
+    readonly inputSchema: {
+        roleId: z.ZodUnion<[z.ZodString, z.ZodNumber]>;
+    };
+    readonly handler: typeof roleDelete;
+}, {
+    readonly name: "openloyalty_acl_get_resources";
+    readonly description: "Get list of available ACL resources. Returns items with code and name for each resource type. Use this to discover available permissions before creating roles.";
+    readonly inputSchema: {};
+    readonly handler: typeof aclGetResources;
+}];

package/dist/tools/role.js

@@ -0,0 +1,160 @@
+import { z } from "zod";
+import { apiGet, apiPost, apiPut, apiDelete } from "../client/http.js";
+import { formatApiError } from "../utils/errors.js";
+// Input Schemas
+export const RoleListInputSchema = {
+    page: z.number().optional().describe("Page number (default: 1)."),
+    perPage: z.number().optional().describe("Items per page (default: 25)."),
+    name: z.string().optional().describe("Filter by role name."),
+    master: z.boolean().optional().describe("Filter by master role status."),
+    default: z.boolean().optional().describe("Filter by default role status."),
+};
+export const RoleCreateInputSchema = {
+    name: z.string().describe("Role name (required)."),
+    permissions: z.array(z.object({
+        resource: z.string().describe("Resource name (e.g., ANALYTICS, EVENTS)."),
+        access: z.string().describe("Access level (e.g., VIEW, MODIFY)."),
+        filterQuery: z.string().optional().describe("Optional filter query."),
+    })).optional().describe("Array of permission definitions."),
+    stores: z.array(z.string()).optional().describe("Store codes to assign access (e.g., ['DEFAULT'])."),
+    default: z.boolean().optional().describe("Whether this is a default role for new admins."),
+};
+export const RoleGetInputSchema = {
+    roleId: z.union([z.string(), z.number()]).describe("The role ID to retrieve."),
+};
+export const RoleUpdateInputSchema = {
+    roleId: z.union([z.string(), z.number()]).describe("The role ID to update."),
+    name: z.string().optional().describe("Role name."),
+    permissions: z.array(z.object({
+        resource: z.string().describe("Resource name."),
+        access: z.string().describe("Access level."),
+        filterQuery: z.string().optional().describe("Optional filter query."),
+    })).optional().describe("Array of permission definitions."),
+    stores: z.array(z.string()).optional().describe("Store codes to assign access."),
+    default: z.boolean().optional().describe("Whether this is a default role."),
+};
+export const RoleDeleteInputSchema = {
+    roleId: z.union([z.string(), z.number()]).describe("The role ID to delete."),
+};
+// Handler functions
+export async function roleList(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.name)
+        params.append("name", input.name);
+    if (input.master !== undefined)
+        params.append("master", String(input.master));
+    if (input.default !== undefined)
+        params.append("default", String(input.default));
+    const queryString = params.toString();
+    const url = `/acl/role${queryString ? `?${queryString}` : ""}`;
+    try {
+        const response = await apiGet(url);
+        return response;
+    }
+    catch (error) {
+        throw formatApiError(error, "openloyalty_role_list");
+    }
+}
+export async function roleCreate(input) {
+    const payload = {
+        name: input.name,
+    };
+    if (input.permissions)
+        payload.permissions = input.permissions;
+    if (input.stores)
+        payload.stores = input.stores;
+    if (input.default !== undefined)
+        payload.default = input.default;
+    try {
+        await apiPost("/acl/role", { role: payload });
+    }
+    catch (error) {
+        throw formatApiError(error, "openloyalty_role_create");
+    }
+}
+export async function roleGet(input) {
+    try {
+        const response = await apiGet(`/acl/role/${input.roleId}`);
+        return response;
+    }
+    catch (error) {
+        throw formatApiError(error, "openloyalty_role_get");
+    }
+}
+export async function roleUpdate(input) {
+    const payload = {};
+    if (input.name)
+        payload.name = input.name;
+    if (input.permissions)
+        payload.permissions = input.permissions;
+    if (input.stores)
+        payload.stores = input.stores;
+    if (input.default !== undefined)
+        payload.default = input.default;
+    try {
+        await apiPut(`/acl/role/${input.roleId}`, { role: payload });
+    }
+    catch (error) {
+        throw formatApiError(error, "openloyalty_role_update");
+    }
+}
+export async function roleDelete(input) {
+    try {
+        await apiDelete(`/acl/role/${input.roleId}`);
+    }
+    catch (error) {
+        throw formatApiError(error, "openloyalty_role_delete");
+    }
+}
+export async function aclGetResources() {
+    try {
+        const response = await apiGet("/acl/resources");
+        return response;
+    }
+    catch (error) {
+        throw formatApiError(error, "openloyalty_acl_get_resources");
+    }
+}
+// Tool definitions
+export const roleToolDefinitions = [
+    {
+        name: "openloyalty_role_list",
+        description: "List all roles with optional filtering. Returns paginated list of roles with id, name, permissions, master status, and default status.",
+        inputSchema: RoleListInputSchema,
+        handler: roleList,
+    },
+    {
+        name: "openloyalty_role_create",
+        description: "Create a new role with permissions. Requires name. Optionally specify permissions (array of {resource, access, filterQuery}) and stores. Returns void on success (201 Created).",
+        inputSchema: RoleCreateInputSchema,
+        handler: roleCreate,
+    },
+    {
+        name: "openloyalty_role_get",
+        description: "Get full role details by ID. Returns role with name, permissions array, master status, default status, and stores.",
+        inputSchema: RoleGetInputSchema,
+        handler: roleGet,
+    },
+    {
+        name: "openloyalty_role_update",
+        description: "Update a role's name, permissions, or stores. Returns void on success (204 No Content).",
+        inputSchema: RoleUpdateInputSchema,
+        handler: roleUpdate,
+    },
+    {
+        name: "openloyalty_role_delete",
+        description: "Delete a role by ID. Returns void on success (204 No Content). Cannot delete roles that are assigned to admin users.",
+        inputSchema: RoleDeleteInputSchema,
+        handler: roleDelete,
+    },
+    {
+        name: "openloyalty_acl_get_resources",
+        description: "Get list of available ACL resources. Returns items with code and name for each resource type. Use this to discover available permissions before creating roles.",
+        inputSchema: {},
+        handler: aclGetResources,
+    },
+];