@open-loyalty/mcp-server 1.0.0

package/dist/tools/points.js

@@ -0,0 +1,306 @@
+import { z } from "zod";
+import { apiGet, apiPost } from "../client/http.js";
+import { formatApiError, OpenLoyaltyError } from "../utils/errors.js";
+import { getConfig } from "../config.js";
+import { buildPaginationParams } from "../utils/pagination.js";
+// Input Schemas
+export const PointsAddInputSchema = {
+    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) to add points to."),
+    points: z.number().describe("Number of points to add (positive number)."),
+    walletCode: z.string().optional().describe("Wallet type code (e.g., 'default'). Uses default wallet if not specified."),
+    comment: z.string().optional().describe("Reason for adding points (max 500 chars)."),
+    expiresInDays: z.number().optional().describe("Days until points expire (1-9999)."),
+    lockedUntilDays: z.number().optional().describe("Days until points become available (1-9999)."),
+};
+export const PointsSpendInputSchema = {
+    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) to spend points from."),
+    points: z.number().describe("Number of points to spend (positive number)."),
+    walletCode: z.string().optional().describe("Wallet type code (e.g., 'default'). Uses default wallet if not specified."),
+    comment: z.string().optional().describe("Reason for spending points (max 500 chars)."),
+};
+export const PointsTransferInputSchema = {
+    storeCode: z.string().optional().describe("Store code. If not provided, uses the default store code from configuration."),
+    senderId: z.string().describe("The sender member ID (UUID)."),
+    receiverId: z.string().describe("The receiver member ID (UUID)."),
+    points: z.number().describe("Number of points to transfer."),
+};
+export const PointsBalanceInputSchema = {
+    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) to get balance for."),
+    walletCode: z.string().optional().describe("Wallet type code. Returns all wallets if not specified."),
+};
+export const PointsHistoryInputSchema = {
+    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) to get history for."),
+    cursor: z.string().optional().describe("Pagination cursor from previous response. If provided, page/perPage are ignored."),
+    page: z.number().optional().describe("Page number (default: 1)."),
+    perPage: z.number().optional().describe("Items per page (default: 10)."),
+    type: z.enum(["adding", "spending", "p2p_spending", "p2p_adding", "blocked", "expired"]).optional().describe("Filter by transfer type."),
+};
+export const PointsHistogramInputSchema = {
+    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) to get histogram for."),
+    pointType: z.enum(["spent", "earned", "expired", "pending"]).describe("Filter by point type (required). One of: spent, earned, expired, pending."),
+    walletCode: z.string().optional().describe("Wallet type code. Uses default if not specified."),
+    interval: z.enum(["day", "week", "month"]).optional().describe("Time interval for aggregation (default: month)."),
+    dateFrom: z.string().optional().describe("Start date for histogram (ISO format: YYYY-MM-DD)."),
+    dateTo: z.string().optional().describe("End date for histogram (ISO format: YYYY-MM-DD)."),
+};
+// Handler functions
+export async function pointsAdd(input) {
+    const config = getConfig();
+    const storeCode = input.storeCode || config.defaultStoreCode;
+    const payload = {
+        points: input.points,
+    };
+    if (input.walletCode)
+        payload.walletCode = input.walletCode;
+    if (input.comment)
+        payload.comment = input.comment;
+    if (input.expiresInDays)
+        payload.expiresInDays = input.expiresInDays;
+    if (input.lockedUntilDays)
+        payload.lockedUntilDays = input.lockedUntilDays;
+    try {
+        const response = await apiPost(`/${storeCode}/points/add`, { transfer: { customer: input.memberId, ...payload } });
+        return { transferId: response.transferId };
+    }
+    catch (error) {
+        throw formatApiError(error, "openloyalty_points_add");
+    }
+}
+export async function pointsSpend(input) {
+    const config = getConfig();
+    const storeCode = input.storeCode || config.defaultStoreCode;
+    const payload = {
+        points: input.points,
+    };
+    if (input.walletCode)
+        payload.walletCode = input.walletCode;
+    if (input.comment)
+        payload.comment = input.comment;
+    try {
+        const response = await apiPost(`/${storeCode}/points/spend`, { transfer: { customer: input.memberId, ...payload } });
+        return { transferId: response.transferId };
+    }
+    catch (error) {
+        // Check for insufficient points error
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        if (errorMessage.includes("NotEnoughPoints") || errorMessage.includes("insufficient")) {
+            throw new OpenLoyaltyError({
+                code: "INSUFFICIENT_BALANCE",
+                message: "Member does not have enough points to complete this operation",
+                hint: `Use points_get_balance(memberId: "${input.memberId}") to check available balance before spending.`,
+                relatedTool: "openloyalty_points_spend",
+            });
+        }
+        throw formatApiError(error, "openloyalty_points_spend");
+    }
+}
+export async function pointsTransfer(input) {
+    const config = getConfig();
+    const storeCode = input.storeCode || config.defaultStoreCode;
+    if (input.senderId === input.receiverId) {
+        throw new Error("Cannot transfer points to yourself. senderId and receiverId must be different.");
+    }
+    const payload = {
+        transfer: {
+            sender: input.senderId,
+            receiver: input.receiverId,
+            points: input.points,
+        },
+    };
+    try {
+        const response = await apiPost(`/${storeCode}/points/transfer`, payload);
+        return { transferId: response.transferId };
+    }
+    catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        if (errorMessage.includes("NotEnoughPoints") || errorMessage.includes("insufficient")) {
+            throw new OpenLoyaltyError({
+                code: "INSUFFICIENT_BALANCE",
+                message: "Sender does not have enough points to transfer",
+                hint: `Use points_get_balance(memberId: "${input.senderId}") to check sender's available balance before transferring.`,
+                relatedTool: "openloyalty_points_transfer",
+            });
+        }
+        throw formatApiError(error, "openloyalty_points_transfer");
+    }
+}
+export async function pointsGetBalance(input) {
+    const config = getConfig();
+    const storeCode = input.storeCode || config.defaultStoreCode;
+    const params = new URLSearchParams();
+    if (input.walletCode)
+        params.append("walletType:code", input.walletCode);
+    const queryString = params.toString();
+    const url = `/${storeCode}/member/${input.memberId}/wallet${queryString ? `?${queryString}` : ""}`;
+    try {
+        const response = await apiGet(url);
+        // Handle different response formats - may return a list of wallets or aggregated data
+        const items = response.items;
+        if (items && items.length > 0) {
+            // Aggregate from wallet list - data is in items[].account object
+            let activeUnits = 0, earnedUnits = 0, spentUnits = 0, lockedUnits = 0, expiredUnits = 0;
+            for (const wallet of items) {
+                // Check for nested account object first (actual API format)
+                const account = wallet.account;
+                if (account) {
+                    activeUnits += account.activeUnits ?? 0;
+                    earnedUnits += account.earnedUnits ?? 0;
+                    spentUnits += account.spentUnits ?? 0;
+                    lockedUnits += account.lockedUnits ?? 0;
+                    expiredUnits += account.expiredUnits ?? 0;
+                }
+                else {
+                    // Fallback for flat structure
+                    activeUnits += wallet.activeUnits ?? 0;
+                    earnedUnits += wallet.earnedUnits ?? 0;
+                    spentUnits += wallet.spentUnits ?? 0;
+                    lockedUnits += wallet.lockedUnits ?? 0;
+                    expiredUnits += wallet.expiredUnits ?? 0;
+                }
+            }
+            return { activeUnits, earnedUnits, spentUnits, lockedUnits, expiredUnits };
+        }
+        // Fallback for single wallet or different response format
+        const account = response.account;
+        return {
+            activeUnits: account?.activeUnits ?? response.activeUnits ?? 0,
+            earnedUnits: account?.earnedUnits ?? response.earnedUnits ?? 0,
+            spentUnits: account?.spentUnits ?? response.spentUnits ?? 0,
+            lockedUnits: account?.lockedUnits ?? response.lockedUnits ?? 0,
+            expiredUnits: account?.expiredUnits ?? response.expiredUnits ?? 0,
+        };
+    }
+    catch (error) {
+        throw formatApiError(error, "openloyalty_points_get_balance");
+    }
+}
+export async function pointsGetHistory(input) {
+    const config = getConfig();
+    const storeCode = input.storeCode || config.defaultStoreCode;
+    const params = new URLSearchParams();
+    params.append("member:id", input.memberId);
+    // Use buildPaginationParams for cursor/page handling
+    buildPaginationParams({ cursor: input.cursor, page: input.page, perPage: input.perPage }, params);
+    if (input.type)
+        params.append("type", input.type);
+    const queryString = params.toString();
+    const url = `/${storeCode}/points?${queryString}`;
+    try {
+        const response = await apiGet(url);
+        const items = response.items || response.transfers || [];
+        const transfers = items.map((t) => {
+            const transfer = t;
+            return {
+                transferId: transfer.transferId,
+                type: transfer.type,
+                points: transfer.value ?? transfer.points,
+                comment: transfer.comment,
+                createdAt: transfer.createdAt,
+            };
+        });
+        const total = response.total || {};
+        return {
+            transfers,
+            total: {
+                all: typeof total.all === 'number' ? total.all : undefined,
+                filtered: typeof total.filtered === 'number' ? total.filtered : undefined,
+            },
+            cursor: response.scroll,
+        };
+    }
+    catch (error) {
+        throw formatApiError(error, "openloyalty_points_get_history");
+    }
+}
+export async function pointsGetHistogram(input) {
+    const config = getConfig();
+    const storeCode = input.storeCode || config.defaultStoreCode;
+    const params = new URLSearchParams();
+    params.append("member:id", input.memberId);
+    // pointType is required by the API: spent|earned|expired|pending
+    params.append("pointType", input.pointType);
+    if (input.walletCode)
+        params.append("walletType:code", input.walletCode);
+    if (input.interval)
+        params.append("interval", input.interval);
+    if (input.dateFrom) {
+        // Calculate days from dateFrom to now
+        const from = new Date(input.dateFrom);
+        const now = new Date();
+        const diffDays = Math.ceil((now.getTime() - from.getTime()) / (1000 * 60 * 60 * 24));
+        params.append("lastDays", String(diffDays));
+    }
+    else {
+        params.append("lastDays", "30");
+    }
+    params.append("futureDays", "0");
+    const queryString = params.toString();
+    const url = `/${storeCode}/points/history?${queryString}`;
+    try {
+        const response = await apiGet(url);
+        const items = Array.isArray(response) ? response : (response.items || []);
+        return items.map((item) => {
+            const data = item;
+            return {
+                date: data.date,
+                earned: data.earned ?? 0,
+                spent: data.spent ?? 0,
+                balance: data.balance ?? 0,
+            };
+        });
+    }
+    catch (error) {
+        throw formatApiError(error, "openloyalty_points_get_histogram");
+    }
+}
+// Tool definitions
+export const pointsToolDefinitions = [
+    {
+        name: "openloyalty_points_add",
+        description: "Add points to member wallet. Points can have optional expiration and lock period. " +
+            "Use for welcome bonuses, manual adjustments, or custom rewards. Returns transferId.",
+        inputSchema: PointsAddInputSchema,
+        handler: pointsAdd,
+    },
+    {
+        name: "openloyalty_points_spend",
+        description: "Deduct points from member wallet. Fails if insufficient balance. " +
+            "Use points_get_balance first to verify available points. Returns transferId.",
+        inputSchema: PointsSpendInputSchema,
+        handler: pointsSpend,
+    },
+    {
+        name: "openloyalty_points_transfer",
+        description: "Transfer points from one member to another (P2P transfer). " +
+            "Sender must have sufficient balance. Returns transferId.",
+        inputSchema: PointsTransferInputSchema,
+        handler: pointsTransfer,
+    },
+    {
+        name: "openloyalty_points_get_balance",
+        description: "Get member points balance breakdown. activeUnits is available for spending. " +
+            "earnedUnits shows lifetime earnings, lockedUnits shows pending points.",
+        inputSchema: PointsBalanceInputSchema,
+        handler: pointsGetBalance,
+    },
+    {
+        name: "openloyalty_points_get_history",
+        description: "Get points transaction history for a member. Filter by type: adding, spending, " +
+            "p2p_spending, p2p_adding, blocked, expired. Returns paginated list of transfers. " +
+            "Supports cursor pagination: provide 'cursor' from previous response to get next page.",
+        inputSchema: PointsHistoryInputSchema,
+        handler: pointsGetHistory,
+    },
+    {
+        name: "openloyalty_points_get_histogram",
+        description: "Get points histogram data for visualization. Shows earning and spending patterns over time. " +
+            "Use interval (day/week/month) to aggregate data and dateFrom/dateTo to filter range.",
+        inputSchema: PointsHistogramInputSchema,
+        handler: pointsGetHistogram,
+    },
+];

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

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

package/dist/tools/points.test.js

@@ -0,0 +1,292 @@
+// src/tools/points.test.ts
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { setupMockAxios, teardownMockAxios, getMockAxios } from '../../tests/mocks/http.mock.js';
+import { pointsFixtures } from '../../tests/fixtures/points.fixtures.js';
+import { pointsAdd, pointsSpend, pointsTransfer, pointsGetBalance, pointsGetHistory, pointsGetHistogram, } from './points.js';
+describe('Points Operations', () => {
+    beforeEach(() => {
+        setupMockAxios();
+    });
+    afterEach(() => {
+        teardownMockAxios();
+    });
+    describe('pointsAdd', () => {
+        it('should add points with transfer wrapper', async () => {
+            const mockAxios = getMockAxios();
+            mockAxios.onPost('/default/points/add').reply(200, pointsFixtures.addResponse);
+            const result = await pointsAdd({
+                memberId: 'member-uuid',
+                points: 100,
+            });
+            expect(result.transferId).toBe('123e4567-e89b-12d3-a456-426614174000');
+            // Verify request body format with transfer wrapper
+            const requestData = JSON.parse(mockAxios.history.post[0].data);
+            expect(requestData).toEqual({
+                transfer: {
+                    customer: 'member-uuid',
+                    points: 100,
+                },
+            });
+        });
+        it('should include optional fields in transfer wrapper', async () => {
+            const mockAxios = getMockAxios();
+            mockAxios.onPost('/default/points/add').reply(200, pointsFixtures.addResponse);
+            await pointsAdd({
+                memberId: 'member-uuid',
+                points: 500,
+                walletCode: 'bonus',
+                comment: 'Welcome bonus',
+                expiresInDays: 90,
+                lockedUntilDays: 7,
+            });
+            const requestData = JSON.parse(mockAxios.history.post[0].data);
+            expect(requestData.transfer.customer).toBe('member-uuid');
+            expect(requestData.transfer.points).toBe(500);
+            expect(requestData.transfer.walletCode).toBe('bonus');
+            expect(requestData.transfer.comment).toBe('Welcome bonus');
+            expect(requestData.transfer.expiresInDays).toBe(90);
+            expect(requestData.transfer.lockedUntilDays).toBe(7);
+        });
+        it('should use custom storeCode when provided', async () => {
+            const mockAxios = getMockAxios();
+            mockAxios.onPost('/custom-store/points/add').reply(200, pointsFixtures.addResponse);
+            await pointsAdd({
+                storeCode: 'custom-store',
+                memberId: 'member-uuid',
+                points: 100,
+            });
+            expect(mockAxios.history.post[0].url).toBe('/custom-store/points/add');
+        });
+    });
+    describe('pointsSpend', () => {
+        it('should spend points with transfer wrapper', async () => {
+            const mockAxios = getMockAxios();
+            mockAxios.onPost('/default/points/spend').reply(200, pointsFixtures.spendResponse);
+            const result = await pointsSpend({
+                memberId: 'member-uuid',
+                points: 50,
+            });
+            expect(result.transferId).toBe('223e4567-e89b-12d3-a456-426614174001');
+            const requestData = JSON.parse(mockAxios.history.post[0].data);
+            expect(requestData).toEqual({
+                transfer: {
+                    customer: 'member-uuid',
+                    points: 50,
+                },
+            });
+        });
+        it('should include optional fields', async () => {
+            const mockAxios = getMockAxios();
+            mockAxios.onPost('/default/points/spend').reply(200, pointsFixtures.spendResponse);
+            await pointsSpend({
+                memberId: 'member-uuid',
+                points: 100,
+                walletCode: 'default',
+                comment: 'Reward redemption',
+            });
+            const requestData = JSON.parse(mockAxios.history.post[0].data);
+            expect(requestData.transfer.walletCode).toBe('default');
+            expect(requestData.transfer.comment).toBe('Reward redemption');
+        });
+        it('should throw error for insufficient points', async () => {
+            const mockAxios = getMockAxios();
+            mockAxios.onPost('/default/points/spend').reply(400, {
+                message: 'NotEnoughPoints',
+                code: 400,
+            });
+            // API returns 400 error which gets thrown
+            await expect(pointsSpend({
+                memberId: 'member-uuid',
+                points: 10000,
+            })).rejects.toThrow();
+        });
+    });
+    describe('pointsTransfer', () => {
+        it('should transfer points between members', async () => {
+            const mockAxios = getMockAxios();
+            mockAxios.onPost('/default/points/transfer').reply(200, pointsFixtures.transferResponse);
+            const result = await pointsTransfer({
+                senderId: 'sender-uuid',
+                receiverId: 'receiver-uuid',
+                points: 100,
+            });
+            expect(result.transferId).toBe('323e4567-e89b-12d3-a456-426614174002');
+            const requestData = JSON.parse(mockAxios.history.post[0].data);
+            expect(requestData).toEqual({
+                transfer: {
+                    sender: 'sender-uuid',
+                    receiver: 'receiver-uuid',
+                    points: 100,
+                },
+            });
+        });
+        it('should throw error when sender equals receiver', async () => {
+            await expect(pointsTransfer({
+                senderId: 'same-uuid',
+                receiverId: 'same-uuid',
+                points: 100,
+            })).rejects.toThrow('Cannot transfer points to yourself');
+        });
+        it('should throw error for insufficient balance on transfer', async () => {
+            const mockAxios = getMockAxios();
+            mockAxios.onPost('/default/points/transfer').reply(400, {
+                message: 'NotEnoughPoints',
+            });
+            // API returns 400 error which gets thrown
+            await expect(pointsTransfer({
+                senderId: 'sender-uuid',
+                receiverId: 'receiver-uuid',
+                points: 10000,
+            })).rejects.toThrow();
+        });
+    });
+    describe('pointsGetBalance', () => {
+        it('should get balance from wallet list response', async () => {
+            const mockAxios = getMockAxios();
+            mockAxios.onGet('/default/member/member-uuid/wallet').reply(200, pointsFixtures.walletResponse);
+            const result = await pointsGetBalance({ memberId: 'member-uuid' });
+            expect(result.activeUnits).toBe(750);
+            expect(result.earnedUnits).toBe(1000);
+            expect(result.spentUnits).toBe(200);
+            expect(result.lockedUnits).toBe(50);
+            expect(result.expiredUnits).toBe(0);
+        });
+        it('should filter by wallet code', async () => {
+            const mockAxios = getMockAxios();
+            mockAxios.onGet(/\/default\/member\/member-uuid\/wallet/).reply(200, pointsFixtures.walletResponse);
+            await pointsGetBalance({
+                memberId: 'member-uuid',
+                walletCode: 'bonus',
+            });
+            const url = mockAxios.history.get[0].url;
+            expect(url).toContain('walletType%3Acode=bonus');
+        });
+        it('should aggregate multiple wallets from nested account objects', async () => {
+            const mockAxios = getMockAxios();
+            mockAxios.onGet('/default/member/member-uuid/wallet').reply(200, {
+                items: [
+                    { account: { activeUnits: 100, earnedUnits: 200, spentUnits: 50, lockedUnits: 25, expiredUnits: 10 } },
+                    { account: { activeUnits: 200, earnedUnits: 300, spentUnits: 100, lockedUnits: 0, expiredUnits: 0 } },
+                ],
+                total: { all: 2, filtered: 2 },
+            });
+            const result = await pointsGetBalance({ memberId: 'member-uuid' });
+            expect(result.activeUnits).toBe(300);
+            expect(result.earnedUnits).toBe(500);
+            expect(result.spentUnits).toBe(150);
+            expect(result.lockedUnits).toBe(25);
+            expect(result.expiredUnits).toBe(10);
+        });
+        it('should handle single wallet response format', async () => {
+            const mockAxios = getMockAxios();
+            mockAxios.onGet('/default/member/member-uuid/wallet').reply(200, {
+                account: {
+                    activeUnits: 500,
+                    earnedUnits: 800,
+                    spentUnits: 300,
+                    lockedUnits: 0,
+                    expiredUnits: 0,
+                },
+            });
+            const result = await pointsGetBalance({ memberId: 'member-uuid' });
+            expect(result.activeUnits).toBe(500);
+            expect(result.earnedUnits).toBe(800);
+        });
+    });
+    describe('pointsGetHistory', () => {
+        it('should get history and map items correctly', async () => {
+            const mockAxios = getMockAxios();
+            mockAxios.onGet(/\/default\/points/).reply(200, pointsFixtures.historyResponse);
+            const result = await pointsGetHistory({ memberId: 'member-uuid' });
+            expect(result.transfers).toHaveLength(2);
+            expect(result.transfers[0].transferId).toBe('transfer-uuid-1');
+            expect(result.transfers[0].type).toBe('adding');
+            expect(result.transfers[0].points).toBe(100);
+            expect(result.transfers[0].comment).toBe('Welcome bonus');
+        });
+        it('should include member:id in query params', async () => {
+            const mockAxios = getMockAxios();
+            mockAxios.onGet(/\/default\/points/).reply(200, pointsFixtures.historyResponse);
+            await pointsGetHistory({ memberId: 'member-uuid' });
+            const url = mockAxios.history.get[0].url;
+            expect(url).toContain('member%3Aid=member-uuid');
+        });
+        it('should include pagination params', async () => {
+            const mockAxios = getMockAxios();
+            mockAxios.onGet(/\/default\/points/).reply(200, pointsFixtures.historyResponse);
+            await pointsGetHistory({
+                memberId: 'member-uuid',
+                page: 2,
+                perPage: 25,
+            });
+            const url = mockAxios.history.get[0].url;
+            expect(url).toContain('_page=2');
+            expect(url).toContain('_itemsOnPage=25');
+        });
+        it('should filter by transfer type', async () => {
+            const mockAxios = getMockAxios();
+            mockAxios.onGet(/\/default\/points/).reply(200, pointsFixtures.historyResponse);
+            await pointsGetHistory({
+                memberId: 'member-uuid',
+                type: 'spending',
+            });
+            const url = mockAxios.history.get[0].url;
+            expect(url).toContain('type=spending');
+        });
+    });
+    describe('pointsGetHistogram', () => {
+        it('should get histogram data', async () => {
+            const mockAxios = getMockAxios();
+            mockAxios.onGet(/\/default\/points\/history/).reply(200, [
+                { date: '2026-01-01', earned: 100, spent: 50, balance: 50 },
+                { date: '2026-01-02', earned: 200, spent: 75, balance: 175 },
+            ]);
+            const result = await pointsGetHistogram({ memberId: 'member-uuid' });
+            expect(result).toHaveLength(2);
+            expect(result[0].date).toBe('2026-01-01');
+            expect(result[0].earned).toBe(100);
+            expect(result[0].spent).toBe(50);
+            expect(result[0].balance).toBe(50);
+        });
+        it('should include member:id in query params', async () => {
+            const mockAxios = getMockAxios();
+            mockAxios.onGet(/\/default\/points\/history/).reply(200, []);
+            await pointsGetHistogram({ memberId: 'member-uuid' });
+            const url = mockAxios.history.get[0].url;
+            expect(url).toContain('member%3Aid=member-uuid');
+        });
+        it('should set interval parameter', async () => {
+            const mockAxios = getMockAxios();
+            mockAxios.onGet(/\/default\/points\/history/).reply(200, []);
+            await pointsGetHistogram({
+                memberId: 'member-uuid',
+                interval: 'week',
+            });
+            const url = mockAxios.history.get[0].url;
+            expect(url).toContain('interval=week');
+        });
+        it('should handle object response format with items', async () => {
+            const mockAxios = getMockAxios();
+            mockAxios.onGet(/\/default\/points\/history/).reply(200, {
+                items: [
+                    { date: '2026-01-01', earned: 100, spent: 50, balance: 50 },
+                ],
+            });
+            const result = await pointsGetHistogram({ memberId: 'member-uuid' });
+            expect(result).toHaveLength(1);
+            expect(result[0].date).toBe('2026-01-01');
+        });
+        it('should calculate lastDays from dateFrom', async () => {
+            const mockAxios = getMockAxios();
+            mockAxios.onGet(/\/default\/points\/history/).reply(200, []);
+            // Set a fixed dateFrom to test calculation
+            await pointsGetHistogram({
+                memberId: 'member-uuid',
+                dateFrom: '2026-01-01',
+            });
+            const url = mockAxios.history.get[0].url;
+            expect(url).toContain('lastDays=');
+            expect(url).toContain('futureDays=0');
+        });
+    });
+});