@vulog/aima-business 1.2.39

package/src/getBusinessUserGlobalById.ts

@@ -0,0 +1,15 @@
+import { Client } from '@vulog/aima-client';
+import { z } from 'zod';
+
+import { BusinessUser } from './types';
+
+export const getBusinessUserGlobalById = async (client: Client, userId: string): Promise<BusinessUser> => {
+    const result = z.string().trim().min(1).uuid().safeParse(userId);
+    if (!result.success) {
+        throw new TypeError('Invalid args', { cause: result.error.issues });
+    }
+
+    return client
+        .get<BusinessUser>(`/boapi/proxy/business/fleets/${client.clientOptions.fleetId}/users/${result.data}`)
+        .then(({ data }) => data);
+};

package/src/getBusinessUsers.test.ts

@@ -0,0 +1,70 @@
+import { describe, test, vi, expect, beforeEach } from 'vitest';
+import { Client } from '@vulog/aima-client';
+import { getBusinessUsers } from './getBusinessUsers';
+
+describe('getBusinessUsers', () => {
+    const getMock = vi.fn();
+    const client = {
+        get: getMock,
+        clientOptions: { fleetId: 'FLEET_ID' },
+    } as unknown as Client;
+
+    const businessId = 'ed539d7d-d815-405b-bc00-71008fb1954c';
+
+    beforeEach(() => {
+        vi.clearAllMocks();
+    });
+
+    test('should call GET with correct endpoint and default pagination', async () => {
+        const mockUsers = [
+            { userId: 'u1', businessId, role: 'MEMBER' },
+            { userId: 'u2', businessId, role: 'ADMIN' },
+        ];
+        getMock.mockResolvedValueOnce({
+            data: mockUsers,
+            headers: { number: 0, size: 100, totalelements: 2, totalpages: 1 },
+        });
+
+        const result = await getBusinessUsers(client, businessId);
+
+        expect(getMock).toHaveBeenCalledTimes(1);
+        const url = getMock.mock.calls[0][0] as string;
+        expect(url).toContain(`/boapi/proxy/business/fleets/FLEET_ID/business/${businessId}/user?`);
+        expect(url).toContain('page=0');
+        expect(url).toContain('size=100');
+        expect(result.data).toEqual(mockUsers);
+        expect(result.page).toBe(0);
+        expect(result.pageSize).toBe(100);
+        expect(result.total).toBe(2);
+        expect(result.totalPages).toBe(1);
+    });
+
+    test('should pass custom pagination options', async () => {
+        getMock.mockResolvedValueOnce({
+            data: [],
+            headers: { number: 2, size: 25, totalelements: 0, totalpages: 0 },
+        });
+
+        await getBusinessUsers(client, businessId, { page: 2, pageSize: 25, sort: 'userId', sortDirection: 'DESC' });
+
+        const url = getMock.mock.calls[0][0] as string;
+        expect(url).toContain('page=2');
+        expect(url).toContain('size=25');
+        expect(url).toContain('DESC');
+    });
+
+    test('should throw TypeError for invalid businessId', async () => {
+        await expect(getBusinessUsers(client, 'not-a-uuid')).rejects.toThrow(TypeError);
+        expect(getMock).not.toHaveBeenCalled();
+    });
+
+    test('should throw TypeError for empty businessId', async () => {
+        await expect(getBusinessUsers(client, '')).rejects.toThrow(TypeError);
+        expect(getMock).not.toHaveBeenCalled();
+    });
+
+    test('should throw TypeError for invalid pagination options', async () => {
+        await expect(getBusinessUsers(client, businessId, { page: -1 })).rejects.toThrow(TypeError);
+        expect(getMock).not.toHaveBeenCalled();
+    });
+});

package/src/getBusinessUsers.ts

@@ -0,0 +1,43 @@
+import { Client } from '@vulog/aima-client';
+import { createPaginableOptionsSchema, PaginableOptions, PaginableResponse } from '@vulog/aima-core';
+import { z } from 'zod';
+
+import { BusinessUser } from './types';
+
+export const getBusinessUsers = async (
+    client: Client,
+    businessId: string,
+    options?: PaginableOptions
+): Promise<PaginableResponse<BusinessUser>> => {
+    const resultId = z.string().trim().min(1).uuid().safeParse(businessId);
+    if (!resultId.success) {
+        throw new TypeError('Invalid args', { cause: resultId.error.issues });
+    }
+
+    const paginableOptionsSchema = createPaginableOptionsSchema();
+
+    const resultOptions = paginableOptionsSchema.safeParse(options ?? {});
+    if (!resultOptions.success) {
+        throw new TypeError('Invalid options', { cause: resultOptions.error.issues });
+    }
+
+    const finalOptions = resultOptions.data;
+
+    const searchParams = new URLSearchParams();
+    searchParams.append('page', finalOptions.page!.toString());
+    searchParams.append('size', finalOptions.pageSize!.toString());
+
+    if (finalOptions.sort) {
+        searchParams.append('sort', `${finalOptions.sort.toString()},${finalOptions.sortDirection!.toString()}`);
+    }
+
+    const url = `/boapi/proxy/business/fleets/${client.clientOptions.fleetId}/business/${resultId.data}/user?${searchParams.toString()}`;
+
+    return client.get<BusinessUser[]>(url).then(({ data, headers }) => ({
+        data,
+        page: headers.number,
+        pageSize: headers.size,
+        total: headers.totalelements,
+        totalPages: headers.totalpages,
+    }));
+};

package/src/getBusinessWallet.test.ts

@@ -0,0 +1,46 @@
+import { describe, test, vi, expect, beforeEach } from 'vitest';
+import { Client } from '@vulog/aima-client';
+import { getBusinessWallet } from './getBusinessWallet';
+
+describe('getBusinessWallet', () => {
+    const getMock = vi.fn();
+    const client = {
+        get: getMock,
+        clientOptions: {
+            fleetId: 'FLEET_ID',
+        },
+    } as unknown as Client;
+
+    beforeEach(() => {
+        vi.clearAllMocks();
+    });
+
+    const BUSINESS_ID = '018ab2b6-71b2-4c76-90bd-6e8d3f268618';
+
+    test('should return the business wallet', async () => {
+        const mockResponse = {
+            balance: 1000,
+            currency: 'EUR',
+        };
+        getMock.mockResolvedValueOnce({ data: mockResponse });
+
+        const result = await getBusinessWallet(client, BUSINESS_ID);
+
+        expect(result).toEqual(mockResponse);
+        expect(getMock).toHaveBeenCalledWith(
+            `/boapi/proxy/business/fleets/FLEET_ID/business/${BUSINESS_ID}/wallet`
+        );
+    });
+
+    test('should throw for empty businessId', async () => {
+        await expect(getBusinessWallet(client, '')).rejects.toThrow(TypeError);
+    });
+
+    test('should throw for non-uuid businessId', async () => {
+        await expect(getBusinessWallet(client, 'not-a-uuid')).rejects.toThrow(TypeError);
+    });
+
+    test('should throw for whitespace-only businessId', async () => {
+        await expect(getBusinessWallet(client, '   ')).rejects.toThrow(TypeError);
+    });
+});

package/src/getBusinessWallet.ts

@@ -0,0 +1,17 @@
+import { Client } from '@vulog/aima-client';
+import { z } from 'zod';
+
+import { BusinessWallet } from './types';
+
+export const getBusinessWallet = async (client: Client, businessId: string): Promise<BusinessWallet> => {
+    const result = z.string().trim().min(1).uuid().safeParse(businessId);
+    if (!result.success) {
+        throw new TypeError('Invalid args', { cause: result.error.issues });
+    }
+
+    return client
+        .get<BusinessWallet>(
+            `/boapi/proxy/business/fleets/${client.clientOptions.fleetId}/business/${result.data}/wallet`
+        )
+        .then(({ data }) => data);
+};

package/src/getBusinesses.test.ts

@@ -0,0 +1,133 @@
+import { describe, test, vi, expect, beforeEach } from 'vitest';
+import { Client } from '@vulog/aima-client';
+import { getBusinesses } from './getBusinesses';
+import { Business } from './types';
+
+describe('getBusinesses', () => {
+    const getMock = vi.fn();
+    const client = {
+        get: getMock,
+        clientOptions: {
+            fleetId: 'FLEET_ID',
+        },
+    } as unknown as Client;
+
+    beforeEach(() => {
+        vi.clearAllMocks();
+    });
+
+    test('should return businesses with default options', async () => {
+        const mockData: Business[] = [
+            { id: 'id-1', name: 'Business One', status: 'ACTIVE' },
+            { id: 'id-2', name: 'Business Two', status: 'INACTIVE' },
+        ];
+
+        const mockHeaders = {
+            number: 0,
+            size: 100,
+            totalelements: 2,
+            totalpages: 1,
+        };
+
+        getMock.mockResolvedValueOnce({
+            data: mockData,
+            headers: mockHeaders,
+        });
+
+        const result = await getBusinesses(client);
+
+        expect(result).toEqual({
+            data: mockData,
+            page: 0,
+            pageSize: 100,
+            total: 2,
+            totalPages: 1,
+        });
+
+        expect(getMock).toHaveBeenCalledWith(
+            expect.stringContaining('/boapi/proxy/business/fleets/FLEET_ID/business')
+        );
+
+        const calledUrl = getMock.mock.calls[0][0];
+        const url = new URL(calledUrl, 'http://example.com');
+        expect(url.searchParams.get('page')).toBe('0');
+        expect(url.searchParams.get('size')).toBe('100');
+    });
+
+    test('should return businesses with custom options', async () => {
+        const mockData: Business[] = [
+            { id: 'id-1', name: 'Business One', status: 'ACTIVE' },
+        ];
+
+        const mockHeaders = {
+            number: 1,
+            size: 50,
+            totalelements: 10,
+            totalpages: 2,
+        };
+
+        getMock.mockResolvedValueOnce({
+            data: mockData,
+            headers: mockHeaders,
+        });
+
+        const options = {
+            page: 1,
+            pageSize: 50,
+            sort: 'name',
+            sortDirection: 'DESC' as const,
+        };
+
+        const result = await getBusinesses(client, options);
+
+        expect(result).toEqual({
+            data: mockData,
+            page: 1,
+            pageSize: 50,
+            total: 10,
+            totalPages: 2,
+        });
+
+        const calledUrl = getMock.mock.calls[0][0];
+        const url = new URL(calledUrl, 'http://example.com');
+        expect(url.searchParams.get('page')).toBe('1');
+        expect(url.searchParams.get('size')).toBe('50');
+        expect(url.searchParams.get('sort')).toBe('name,DESC');
+    });
+
+    test('should handle empty response', async () => {
+        const mockHeaders = {
+            number: 0,
+            size: 100,
+            totalelements: 0,
+            totalpages: 0,
+        };
+
+        getMock.mockResolvedValueOnce({
+            data: [],
+            headers: mockHeaders,
+        });
+
+        const result = await getBusinesses(client);
+
+        expect(result).toEqual({
+            data: [],
+            page: 0,
+            pageSize: 100,
+            total: 0,
+            totalPages: 0,
+        });
+    });
+
+    test('should throw error for invalid page number', async () => {
+        await expect(getBusinesses(client, { page: -1 })).rejects.toThrow('Invalid options');
+    });
+
+    test('should throw error for invalid page size', async () => {
+        await expect(getBusinesses(client, { pageSize: 0 })).rejects.toThrow('Invalid options');
+    });
+
+    test('should throw error for invalid sort direction', async () => {
+        await expect(getBusinesses(client, { sortDirection: 'INVALID' as any })).rejects.toThrow('Invalid options');
+    });
+});

package/src/getBusinesses.ts

@@ -0,0 +1,36 @@
+import { Client } from '@vulog/aima-client';
+import { createPaginableOptionsSchema, PaginableOptions, PaginableResponse } from '@vulog/aima-core';
+
+import { Business } from './types';
+
+export const getBusinesses = async (
+    client: Client,
+    options?: PaginableOptions
+): Promise<PaginableResponse<Business>> => {
+    const paginableOptionsSchema = createPaginableOptionsSchema();
+
+    const resultOptions = paginableOptionsSchema.safeParse(options ?? {});
+    if (!resultOptions.success) {
+        throw new TypeError('Invalid options', { cause: resultOptions.error.issues });
+    }
+
+    const finalOptions = resultOptions.data;
+
+    const searchParams = new URLSearchParams();
+    searchParams.append('page', finalOptions.page!.toString());
+    searchParams.append('size', finalOptions.pageSize!.toString());
+
+    if (finalOptions.sort) {
+        searchParams.append('sort', `${finalOptions.sort.toString()},${finalOptions.sortDirection!.toString()}`);
+    }
+
+    const url = `/boapi/proxy/business/fleets/${client.clientOptions.fleetId}/business?${searchParams.toString()}`;
+
+    return client.get<Business[]>(url).then(({ data, headers }) => ({
+        data,
+        page: headers.number,
+        pageSize: headers.size,
+        total: headers.totalelements,
+        totalPages: headers.totalpages,
+    }));
+};

package/src/getEntityBalance.ts

@@ -0,0 +1,17 @@
+import { Client } from '@vulog/aima-client';
+import { z } from 'zod';
+
+import { EntityBalance } from './types';
+
+export const getEntityBalance = async (client: Client, entityId: string): Promise<EntityBalance> => {
+    const result = z.string().trim().min(1).uuid().safeParse(entityId);
+    if (!result.success) {
+        throw new TypeError('Invalid args', { cause: result.error.issues });
+    }
+
+    return client
+        .get<EntityBalance>(
+            `/boapi/proxy/business/fleets/${client.clientOptions.fleetId}/billing/entity/${result.data}/balance`
+        )
+        .then(({ data }) => data);
+};

package/src/getEntityProducts.ts

@@ -0,0 +1,15 @@
+import { Client } from '@vulog/aima-client';
+import { z } from 'zod';
+
+export const getEntityProducts = async (client: Client, entityId: string): Promise<any[]> => {
+    const result = z.string().trim().min(1).uuid().safeParse(entityId);
+    if (!result.success) {
+        throw new TypeError('Invalid args', { cause: result.error.issues });
+    }
+
+    return client
+        .get<
+            any[]
+        >(`/boapi/proxy/business/fleets/${client.clientOptions.fleetId}/billing/entity/${result.data}/product`)
+        .then(({ data }) => data);
+};

package/src/getEntityTrips.ts

@@ -0,0 +1,13 @@
+import { Client } from '@vulog/aima-client';
+import { z } from 'zod';
+
+export const getEntityTrips = async (client: Client, entityId: string): Promise<any[]> => {
+    const result = z.string().trim().min(1).uuid().safeParse(entityId);
+    if (!result.success) {
+        throw new TypeError('Invalid args', { cause: result.error.issues });
+    }
+
+    return client
+        .get<any[]>(`/boapi/proxy/business/fleets/${client.clientOptions.fleetId}/billing/entity/${result.data}/trip`)
+        .then(({ data }) => data);
+};

package/src/getEntityTripsCost.ts

@@ -0,0 +1,17 @@
+import { Client } from '@vulog/aima-client';
+import { z } from 'zod';
+
+import { EntityTripsCost } from './types';
+
+export const getEntityTripsCost = async (client: Client, entityId: string): Promise<EntityTripsCost> => {
+    const result = z.string().trim().min(1).uuid().safeParse(entityId);
+    if (!result.success) {
+        throw new TypeError('Invalid args', { cause: result.error.issues });
+    }
+
+    return client
+        .get<EntityTripsCost>(
+            `/boapi/proxy/business/fleets/${client.clientOptions.fleetId}/billing/entity/${result.data}/trips/cost`
+        )
+        .then(({ data }) => data);
+};

package/src/getInvitationRequest.test.ts

@@ -0,0 +1,46 @@
+import { describe, test, vi, expect, beforeEach } from 'vitest';
+import { Client } from '@vulog/aima-client';
+import { getInvitationRequest } from './getInvitationRequest';
+
+describe('getInvitationRequest', () => {
+    const getMock = vi.fn();
+    const client = {
+        get: getMock,
+        clientOptions: {
+            fleetId: 'FLEET_ID',
+        },
+    } as unknown as Client;
+
+    beforeEach(() => {
+        vi.clearAllMocks();
+    });
+
+    const INVITATION_ID = '018ab2b6-71b2-4c76-90bd-6e8d3f268618';
+
+    test('should return an invitation request by id', async () => {
+        const mockResponse = { id: INVITATION_ID, status: 'PENDING' };
+        getMock.mockResolvedValueOnce({ data: mockResponse });
+
+        const result = await getInvitationRequest(client, INVITATION_ID);
+
+        expect(result).toEqual(mockResponse);
+        expect(getMock).toHaveBeenCalledWith(
+            `/boapi/proxy/business/fleets/FLEET_ID/invitationRequest/${INVITATION_ID}`
+        );
+    });
+
+    test('should throw for empty invitationId', async () => {
+        await expect(getInvitationRequest(client, '')).rejects.toThrow(TypeError);
+        expect(getMock).not.toHaveBeenCalled();
+    });
+
+    test('should throw for non-uuid invitationId', async () => {
+        await expect(getInvitationRequest(client, 'not-a-uuid')).rejects.toThrow(TypeError);
+        expect(getMock).not.toHaveBeenCalled();
+    });
+
+    test('should throw for whitespace-only invitationId', async () => {
+        await expect(getInvitationRequest(client, '   ')).rejects.toThrow(TypeError);
+        expect(getMock).not.toHaveBeenCalled();
+    });
+});

package/src/getInvitationRequest.ts

@@ -0,0 +1,17 @@
+import { Client } from '@vulog/aima-client';
+import { z } from 'zod';
+
+import { InvitationRequest } from './types';
+
+export const getInvitationRequest = async (client: Client, invitationId: string): Promise<InvitationRequest> => {
+    const result = z.string().trim().min(1).uuid().safeParse(invitationId);
+    if (!result.success) {
+        throw new TypeError('Invalid args', { cause: result.error.issues });
+    }
+
+    return client
+        .get<InvitationRequest>(
+            `/boapi/proxy/business/fleets/${client.clientOptions.fleetId}/invitationRequest/${result.data}`
+        )
+        .then(({ data }) => data);
+};

package/src/getInvoicePdf.test.ts

@@ -0,0 +1,62 @@
+import { describe, test, vi, expect, beforeEach } from 'vitest';
+import { Client } from '@vulog/aima-client';
+import { getInvoicePdf } from './getInvoicePdf';
+
+describe('getInvoicePdf', () => {
+    const getMock = vi.fn();
+    const client = {
+        get: getMock,
+        clientOptions: { fleetId: 'FLEET_ID' },
+    } as unknown as Client;
+
+    const INVOICE_ID = '018ab2b6-71b2-4c76-90bd-6e8d3f268618';
+
+    beforeEach(() => {
+        vi.clearAllMocks();
+    });
+
+    test('should return ArrayBuffer when pdf has content', async () => {
+        const mockBuffer = new ArrayBuffer(1024);
+        getMock.mockResolvedValueOnce({ data: mockBuffer });
+
+        const result = await getInvoicePdf(client, INVOICE_ID);
+
+        expect(result).toBe(mockBuffer);
+        expect(getMock).toHaveBeenCalledWith(
+            `/boapi/proxy/business/fleets/FLEET_ID/invoices/${INVOICE_ID}/pdf`,
+            { responseType: 'arraybuffer' }
+        );
+    });
+
+    test('should return null when pdf is empty', async () => {
+        const emptyBuffer = new ArrayBuffer(0);
+        getMock.mockResolvedValueOnce({ data: emptyBuffer });
+
+        const result = await getInvoicePdf(client, INVOICE_ID);
+
+        expect(result).toBeNull();
+    });
+
+    test('should return null when data is null', async () => {
+        getMock.mockResolvedValueOnce({ data: null });
+
+        const result = await getInvoicePdf(client, INVOICE_ID);
+
+        expect(result).toBeNull();
+    });
+
+    test('should throw for empty invoiceId', async () => {
+        await expect(getInvoicePdf(client, '')).rejects.toThrow(TypeError);
+        expect(getMock).not.toHaveBeenCalled();
+    });
+
+    test('should throw for non-uuid invoiceId', async () => {
+        await expect(getInvoicePdf(client, 'not-a-uuid')).rejects.toThrow(TypeError);
+        expect(getMock).not.toHaveBeenCalled();
+    });
+
+    test('should throw for whitespace-only invoiceId', async () => {
+        await expect(getInvoicePdf(client, '   ')).rejects.toThrow(TypeError);
+        expect(getMock).not.toHaveBeenCalled();
+    });
+});

package/src/getInvoicePdf.ts

@@ -0,0 +1,16 @@
+import { Client } from '@vulog/aima-client';
+import { z } from 'zod';
+
+export const getInvoicePdf = async (client: Client, invoiceId: string): Promise<ArrayBuffer | null> => {
+    const result = z.string().trim().min(1).uuid().safeParse(invoiceId);
+    if (!result.success) {
+        throw new TypeError('Invalid args', { cause: result.error.issues });
+    }
+
+    const { data } = await client.get<ArrayBuffer>(
+        `/boapi/proxy/business/fleets/${client.clientOptions.fleetId}/invoices/${result.data}/pdf`,
+        { responseType: 'arraybuffer' }
+    );
+
+    return data && data.byteLength > 0 ? data : null;
+};

package/src/getInvoiceRefundNote.ts

@@ -0,0 +1,17 @@
+import { Client } from '@vulog/aima-client';
+import { z } from 'zod';
+
+import { InvoiceRefundNote } from './types';
+
+export const getInvoiceRefundNote = async (client: Client, invoiceId: string): Promise<InvoiceRefundNote> => {
+    const result = z.string().trim().min(1).uuid().safeParse(invoiceId);
+    if (!result.success) {
+        throw new TypeError('Invalid args', { cause: result.error.issues });
+    }
+
+    return client
+        .get<InvoiceRefundNote>(
+            `/boapi/proxy/business/fleets/${client.clientOptions.fleetId}/invoices/${result.data}/refundNote`
+        )
+        .then(({ data }) => data);
+};

package/src/getInvoiceRefundableAmount.ts

@@ -0,0 +1,20 @@
+import { Client } from '@vulog/aima-client';
+import { z } from 'zod';
+
+import { InvoiceRefundableAmount } from './types';
+
+export const getInvoiceRefundableAmount = async (
+    client: Client,
+    invoiceId: string
+): Promise<InvoiceRefundableAmount> => {
+    const result = z.string().trim().min(1).uuid().safeParse(invoiceId);
+    if (!result.success) {
+        throw new TypeError('Invalid args', { cause: result.error.issues });
+    }
+
+    return client
+        .get<InvoiceRefundableAmount>(
+            `/boapi/proxy/business/fleets/${client.clientOptions.fleetId}/invoices/${result.data}/refundableAmount`
+        )
+        .then(({ data }) => data);
+};

package/src/getOngoingTripNotes.ts

@@ -0,0 +1,17 @@
+import { Client } from '@vulog/aima-client';
+import { z } from 'zod';
+
+import { TripNote } from './types';
+
+export const getOngoingTripNotes = async (client: Client, tripId: string): Promise<TripNote[]> => {
+    const result = z.string().trim().min(1).uuid().safeParse(tripId);
+    if (!result.success) {
+        throw new TypeError('Invalid args', { cause: result.error.issues });
+    }
+
+    return client
+        .get<
+            TripNote[]
+        >(`/boapi/proxy/business/fleets/${client.clientOptions.fleetId}/ongoingTrip/${result.data}/notes`)
+        .then(({ data }) => data);
+};