@open-loyalty/mcp-server 1.0.0

package/dist/tools/member.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/tools/member.test.js

@@ -0,0 +1,213 @@
+// src/tools/member.test.ts
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { setupMockAxios, teardownMockAxios, getMockAxios } from '../../tests/mocks/http.mock.js';
+import { memberFixtures } from '../../tests/fixtures/member.fixtures.js';
+import { memberCreate, memberGet, memberList, memberUpdate, memberActivate, memberDeactivate, memberDelete, memberGetTierProgress, memberAssignTier, memberRemoveManualTier, } from './member.js';
+describe('Member Operations', () => {
+    beforeEach(() => {
+        setupMockAxios();
+    });
+    afterEach(() => {
+        teardownMockAxios();
+    });
+    describe('memberCreate', () => {
+        it('should create member with required fields only', async () => {
+            const mockAxios = getMockAxios();
+            mockAxios.onPost('/default/member').reply(200, memberFixtures.createResponse);
+            const result = await memberCreate({
+                email: 'test@example.com',
+            });
+            expect(result).toEqual({
+                memberId: '550e8400-e29b-41d4-a716-446655440000',
+                loyaltyCardNumber: 'CARD123456789',
+                email: 'test@example.com',
+            });
+            // Verify request body format with customer wrapper
+            const requestData = JSON.parse(mockAxios.history.post[0].data);
+            expect(requestData).toEqual({
+                customer: {
+                    email: 'test@example.com',
+                },
+            });
+        });
+        it('should create member with all optional fields', async () => {
+            const mockAxios = getMockAxios();
+            mockAxios.onPost('/default/member').reply(200, {
+                customerId: 'full-uuid',
+                loyaltyCardNumber: 'CUSTOM123',
+                email: 'full@example.com',
+            });
+            const result = await memberCreate({
+                email: 'full@example.com',
+                firstName: 'John',
+                lastName: 'Doe',
+                phone: '+1234567890',
+                birthDate: '1990-01-15',
+                gender: 'male',
+                loyaltyCardNumber: 'CUSTOM123',
+                agreement1: true,
+                agreement2: false,
+                agreement3: true,
+                address: {
+                    street: '123 Main St',
+                    city: 'New York',
+                    postal: '10001',
+                    country: 'US',
+                },
+            });
+            expect(result.memberId).toBe('full-uuid');
+            // Verify all fields in request
+            const requestData = JSON.parse(mockAxios.history.post[0].data);
+            expect(requestData.customer.firstName).toBe('John');
+            expect(requestData.customer.lastName).toBe('Doe');
+            expect(requestData.customer.address.city).toBe('New York');
+            expect(requestData.customer.agreement1).toBe(true);
+            expect(requestData.customer.agreement2).toBe(false);
+        });
+        it('should use custom storeCode when provided', async () => {
+            const mockAxios = getMockAxios();
+            mockAxios.onPost('/custom-store/member').reply(200, {
+                customerId: 'uuid',
+                email: 'test@example.com',
+            });
+            await memberCreate({
+                storeCode: 'custom-store',
+                email: 'test@example.com',
+            });
+            expect(mockAxios.history.post[0].url).toBe('/custom-store/member');
+        });
+        it('should throw formatted error on API error', async () => {
+            const mockAxios = getMockAxios();
+            mockAxios.onPost('/default/member').reply(400, {
+                message: 'Email already exists',
+                code: 400,
+            });
+            await expect(memberCreate({ email: 'duplicate@example.com' }))
+                .rejects.toThrow();
+        });
+    });
+    describe('memberGet', () => {
+        it('should get member details and map customerId to memberId', async () => {
+            const mockAxios = getMockAxios();
+            mockAxios.onGet('/default/member/member-uuid').reply(200, memberFixtures.getResponse);
+            const result = await memberGet({ memberId: 'member-uuid' });
+            expect(result.memberId).toBe('550e8400-e29b-41d4-a716-446655440000');
+            expect(result.email).toBe('test@example.com');
+            expect(result.firstName).toBe('John');
+            expect(result.levelName).toBe('Silver');
+        });
+        it('should use custom storeCode', async () => {
+            const mockAxios = getMockAxios();
+            mockAxios.onGet('/other-store/member/id123').reply(200, memberFixtures.getResponse);
+            await memberGet({ storeCode: 'other-store', memberId: 'id123' });
+            expect(mockAxios.history.get[0].url).toBe('/other-store/member/id123');
+        });
+    });
+    describe('memberList', () => {
+        it('should list members and map customerId to memberId', async () => {
+            const mockAxios = getMockAxios();
+            mockAxios.onGet('/default/member').reply(200, memberFixtures.listResponse);
+            const result = await memberList({});
+            expect(result.members).toHaveLength(2);
+            expect(result.members[0].memberId).toBe('uuid-1');
+            expect(result.members[0].email).toBe('user1@example.com');
+            expect(result.total.all).toBe(100);
+            expect(result.total.filtered).toBe(2);
+        });
+        it('should include pagination params with correct names', async () => {
+            const mockAxios = getMockAxios();
+            mockAxios.onGet(/\/default\/member/).reply(200, memberFixtures.listResponse);
+            await memberList({ 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\/member/).reply(200, memberFixtures.listResponse);
+            await memberList({
+                email: 'test@example.com',
+                firstName: 'John',
+                active: true,
+            });
+            const url = mockAxios.history.get[0].url;
+            expect(url).toContain('email=test%40example.com');
+            expect(url).toContain('firstName=John');
+            expect(url).toContain('active=true');
+        });
+    });
+    describe('memberUpdate', () => {
+        it('should update member with customer wrapper', async () => {
+            const mockAxios = getMockAxios();
+            mockAxios.onPut('/default/member/member-uuid').reply(200);
+            await memberUpdate({
+                memberId: 'member-uuid',
+                firstName: 'Jane',
+                lastName: 'Smith',
+            });
+            const requestData = JSON.parse(mockAxios.history.put[0].data);
+            expect(requestData).toEqual({
+                customer: {
+                    firstName: 'Jane',
+                    lastName: 'Smith',
+                },
+            });
+        });
+    });
+    describe('memberActivate', () => {
+        it('should call activate endpoint', async () => {
+            const mockAxios = getMockAxios();
+            mockAxios.onPost('/default/member/member-uuid/activate').reply(200);
+            await memberActivate({ memberId: 'member-uuid' });
+            expect(mockAxios.history.post[0].url).toBe('/default/member/member-uuid/activate');
+        });
+    });
+    describe('memberDeactivate', () => {
+        it('should call deactivate endpoint', async () => {
+            const mockAxios = getMockAxios();
+            mockAxios.onPost('/default/member/member-uuid/deactivate').reply(200);
+            await memberDeactivate({ memberId: 'member-uuid' });
+            expect(mockAxios.history.post[0].url).toBe('/default/member/member-uuid/deactivate');
+        });
+    });
+    describe('memberDelete', () => {
+        it('should call delete endpoint', async () => {
+            const mockAxios = getMockAxios();
+            mockAxios.onDelete('/default/member/member-uuid').reply(200);
+            await memberDelete({ memberId: 'member-uuid' });
+            expect(mockAxios.history.delete[0].url).toBe('/default/member/member-uuid');
+        });
+    });
+    describe('memberGetTierProgress', () => {
+        it('should get tier progress information', async () => {
+            const mockAxios = getMockAxios();
+            mockAxios.onGet('/default/member/member-uuid/tier').reply(200, memberFixtures.tierProgressResponse);
+            const result = await memberGetTierProgress({ memberId: 'member-uuid' });
+            expect(result.currentTier?.name).toBe('Silver');
+            expect(result.nextTier?.name).toBe('Gold');
+            expect(result.currentValue).toBe(750);
+            expect(result.requiredValue).toBe(1000);
+            expect(result.progressPercent).toBe(75);
+        });
+    });
+    describe('memberAssignTier', () => {
+        it('should assign tier to member', async () => {
+            const mockAxios = getMockAxios();
+            mockAxios.onPost('/default/member/member-uuid/tier').reply(200);
+            await memberAssignTier({
+                memberId: 'member-uuid',
+                levelId: 'gold-level-uuid',
+            });
+            const requestData = JSON.parse(mockAxios.history.post[0].data);
+            expect(requestData.levelId).toBe('gold-level-uuid');
+        });
+    });
+    describe('memberRemoveManualTier', () => {
+        it('should remove manual tier assignment', async () => {
+            const mockAxios = getMockAxios();
+            mockAxios.onDelete('/default/member/member-uuid/tier').reply(200);
+            await memberRemoveManualTier({ memberId: 'member-uuid' });
+            expect(mockAxios.history.delete[0].url).toBe('/default/member/member-uuid/tier');
+        });
+    });
+});

package/dist/tools/points.d.ts

@@ -0,0 +1,188 @@
+import { z } from "zod";
+export declare const PointsAddInputSchema: {
+    storeCode: z.ZodOptional<z.ZodString>;
+    memberId: z.ZodString;
+    points: z.ZodNumber;
+    walletCode: z.ZodOptional<z.ZodString>;
+    comment: z.ZodOptional<z.ZodString>;
+    expiresInDays: z.ZodOptional<z.ZodNumber>;
+    lockedUntilDays: z.ZodOptional<z.ZodNumber>;
+};
+export declare const PointsSpendInputSchema: {
+    storeCode: z.ZodOptional<z.ZodString>;
+    memberId: z.ZodString;
+    points: z.ZodNumber;
+    walletCode: z.ZodOptional<z.ZodString>;
+    comment: z.ZodOptional<z.ZodString>;
+};
+export declare const PointsTransferInputSchema: {
+    storeCode: z.ZodOptional<z.ZodString>;
+    senderId: z.ZodString;
+    receiverId: z.ZodString;
+    points: z.ZodNumber;
+};
+export declare const PointsBalanceInputSchema: {
+    storeCode: z.ZodOptional<z.ZodString>;
+    memberId: z.ZodString;
+    walletCode: z.ZodOptional<z.ZodString>;
+};
+export declare const PointsHistoryInputSchema: {
+    storeCode: z.ZodOptional<z.ZodString>;
+    memberId: z.ZodString;
+    cursor: z.ZodOptional<z.ZodString>;
+    page: z.ZodOptional<z.ZodNumber>;
+    perPage: z.ZodOptional<z.ZodNumber>;
+    type: z.ZodOptional<z.ZodEnum<["adding", "spending", "p2p_spending", "p2p_adding", "blocked", "expired"]>>;
+};
+export declare const PointsHistogramInputSchema: {
+    storeCode: z.ZodOptional<z.ZodString>;
+    memberId: z.ZodString;
+    pointType: z.ZodEnum<["spent", "earned", "expired", "pending"]>;
+    walletCode: z.ZodOptional<z.ZodString>;
+    interval: z.ZodOptional<z.ZodEnum<["day", "week", "month"]>>;
+    dateFrom: z.ZodOptional<z.ZodString>;
+    dateTo: z.ZodOptional<z.ZodString>;
+};
+export declare function pointsAdd(input: {
+    storeCode?: string;
+    memberId: string;
+    points: number;
+    walletCode?: string;
+    comment?: string;
+    expiresInDays?: number;
+    lockedUntilDays?: number;
+}): Promise<{
+    transferId: string;
+}>;
+export declare function pointsSpend(input: {
+    storeCode?: string;
+    memberId: string;
+    points: number;
+    walletCode?: string;
+    comment?: string;
+}): Promise<{
+    transferId: string;
+}>;
+export declare function pointsTransfer(input: {
+    storeCode?: string;
+    senderId: string;
+    receiverId: string;
+    points: number;
+}): Promise<{
+    transferId: string;
+}>;
+export declare function pointsGetBalance(input: {
+    storeCode?: string;
+    memberId: string;
+    walletCode?: string;
+}): Promise<{
+    activeUnits: number;
+    earnedUnits: number;
+    spentUnits: number;
+    lockedUnits: number;
+    expiredUnits: number;
+}>;
+export declare function pointsGetHistory(input: {
+    storeCode?: string;
+    memberId: string;
+    cursor?: string;
+    page?: number;
+    perPage?: number;
+    type?: string;
+}): Promise<{
+    transfers: Array<{
+        transferId: string;
+        type: string;
+        points: number;
+        comment?: string;
+        createdAt: string;
+    }>;
+    total: {
+        all?: number;
+        filtered?: number;
+    };
+    cursor?: string;
+}>;
+export declare function pointsGetHistogram(input: {
+    storeCode?: string;
+    memberId: string;
+    pointType: string;
+    walletCode?: string;
+    interval?: string;
+    dateFrom?: string;
+    dateTo?: string;
+}): Promise<Array<{
+    date: string;
+    earned: number;
+    spent: number;
+    balance: number;
+}>>;
+export declare const pointsToolDefinitions: readonly [{
+    readonly name: "openloyalty_points_add";
+    readonly description: string;
+    readonly inputSchema: {
+        storeCode: z.ZodOptional<z.ZodString>;
+        memberId: z.ZodString;
+        points: z.ZodNumber;
+        walletCode: z.ZodOptional<z.ZodString>;
+        comment: z.ZodOptional<z.ZodString>;
+        expiresInDays: z.ZodOptional<z.ZodNumber>;
+        lockedUntilDays: z.ZodOptional<z.ZodNumber>;
+    };
+    readonly handler: typeof pointsAdd;
+}, {
+    readonly name: "openloyalty_points_spend";
+    readonly description: string;
+    readonly inputSchema: {
+        storeCode: z.ZodOptional<z.ZodString>;
+        memberId: z.ZodString;
+        points: z.ZodNumber;
+        walletCode: z.ZodOptional<z.ZodString>;
+        comment: z.ZodOptional<z.ZodString>;
+    };
+    readonly handler: typeof pointsSpend;
+}, {
+    readonly name: "openloyalty_points_transfer";
+    readonly description: string;
+    readonly inputSchema: {
+        storeCode: z.ZodOptional<z.ZodString>;
+        senderId: z.ZodString;
+        receiverId: z.ZodString;
+        points: z.ZodNumber;
+    };
+    readonly handler: typeof pointsTransfer;
+}, {
+    readonly name: "openloyalty_points_get_balance";
+    readonly description: string;
+    readonly inputSchema: {
+        storeCode: z.ZodOptional<z.ZodString>;
+        memberId: z.ZodString;
+        walletCode: z.ZodOptional<z.ZodString>;
+    };
+    readonly handler: typeof pointsGetBalance;
+}, {
+    readonly name: "openloyalty_points_get_history";
+    readonly description: string;
+    readonly inputSchema: {
+        storeCode: z.ZodOptional<z.ZodString>;
+        memberId: z.ZodString;
+        cursor: z.ZodOptional<z.ZodString>;
+        page: z.ZodOptional<z.ZodNumber>;
+        perPage: z.ZodOptional<z.ZodNumber>;
+        type: z.ZodOptional<z.ZodEnum<["adding", "spending", "p2p_spending", "p2p_adding", "blocked", "expired"]>>;
+    };
+    readonly handler: typeof pointsGetHistory;
+}, {
+    readonly name: "openloyalty_points_get_histogram";
+    readonly description: string;
+    readonly inputSchema: {
+        storeCode: z.ZodOptional<z.ZodString>;
+        memberId: z.ZodString;
+        pointType: z.ZodEnum<["spent", "earned", "expired", "pending"]>;
+        walletCode: z.ZodOptional<z.ZodString>;
+        interval: z.ZodOptional<z.ZodEnum<["day", "week", "month"]>>;
+        dateFrom: z.ZodOptional<z.ZodString>;
+        dateTo: z.ZodOptional<z.ZodString>;
+    };
+    readonly handler: typeof pointsGetHistogram;
+}];