@vulog/aima-business 1.2.39

package/src/getOngoingTrips.test.ts

@@ -0,0 +1,43 @@
+import { describe, test, vi, expect, beforeEach } from 'vitest';
+import { Client } from '@vulog/aima-client';
+import { getOngoingTrips } from './getOngoingTrips';
+
+describe('getOngoingTrips', () => {
+    const getMock = vi.fn();
+    const client = {
+        get: getMock,
+        clientOptions: {
+            fleetId: 'FLEET_ID',
+        },
+    } as unknown as Client;
+
+    beforeEach(() => {
+        vi.clearAllMocks();
+    });
+
+    test('should return an array of ongoing trips', async () => {
+        const mockResponse = [
+            { tripId: '018ab2b6-71b2-4c76-90bd-6e8d3f268618' },
+            { tripId: '129bc3c7-82c3-5d87-a1ce-7f9e4g379729' },
+        ];
+        getMock.mockResolvedValueOnce({ data: mockResponse });
+
+        const result = await getOngoingTrips(client);
+
+        expect(result).toEqual(mockResponse);
+        expect(getMock).toHaveBeenCalledWith(
+            '/boapi/proxy/business/fleets/FLEET_ID/trip/ongoing'
+        );
+    });
+
+    test('should return an empty array when no ongoing trips', async () => {
+        getMock.mockResolvedValueOnce({ data: [] });
+
+        const result = await getOngoingTrips(client);
+
+        expect(result).toEqual([]);
+        expect(getMock).toHaveBeenCalledWith(
+            '/boapi/proxy/business/fleets/FLEET_ID/trip/ongoing'
+        );
+    });
+});

package/src/getOngoingTrips.ts

@@ -0,0 +1,9 @@
+import { Client } from '@vulog/aima-client';
+
+import { BusinessTrip } from './types';
+
+export const getOngoingTrips = async (client: Client): Promise<BusinessTrip[]> => {
+    return client
+        .get<BusinessTrip[]>(`/boapi/proxy/business/fleets/${client.clientOptions.fleetId}/trip/ongoing`)
+        .then(({ data }) => data);
+};

package/src/getStripePublishableKey.ts

@@ -0,0 +1,9 @@
+import { Client } from '@vulog/aima-client';
+
+import { StripeConfig } from './types';
+
+export const getStripePublishableKey = async (client: Client): Promise<StripeConfig> => {
+    return client
+        .get<StripeConfig>(`/boapi/proxy/business/fleets/${client.clientOptions.fleetId}/stripe/config/key`)
+        .then(({ data }) => data);
+};

package/src/getStripeSetup.ts

@@ -0,0 +1,17 @@
+import { Client } from '@vulog/aima-client';
+import { z } from 'zod';
+
+import { StripeSetup } from './types';
+
+export const getStripeSetup = async (client: Client, businessId: string): Promise<StripeSetup> => {
+    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<StripeSetup>(
+            `/boapi/proxy/business/fleets/${client.clientOptions.fleetId}/stripe/businesses/${result.data}/add`
+        )
+        .then(({ data }) => data);
+};

package/src/index.ts

@@ -0,0 +1,58 @@
+export * from './addBusinessCredit';
+export * from './addStripePayment';
+export * from './addTripNote';
+export * from './addUserToBusiness';
+export * from './archiveBusinessProfile';
+export * from './bulkAddBusinessUsers';
+export * from './businessDelegatedAdmin';
+export * from './businessOwner';
+export * from './chargeBusinessProduct';
+export * from './createBusiness';
+export * from './createBusinessCostCenter';
+export * from './deactivateBusinessProfile';
+export * from './deleteBusinessCostCenter';
+export * from './deleteInvitationRequest';
+export * from './getBillingGroups';
+export * from './getBusinessById';
+export * from './getBusinessContacts';
+export * from './getBusinessCostCenterById';
+export * from './getBusinessCostCenters';
+export * from './getBusinesses';
+export * from './getBusinessInviteLink';
+export * from './getBusinessInvoiceProducts';
+export * from './getBusinessInvoices';
+export * from './getBusinessInvoiceTrips';
+export * from './getBusinessPaymentDetails';
+export * from './getBusinessProducts';
+export * from './getBusinessTripById';
+export * from './getBusinessUserById';
+export * from './getBusinessUserGlobalById';
+export * from './getBusinessUsers';
+export * from './getBusinessWallet';
+export * from './getEntityBalance';
+export * from './getEntityProducts';
+export * from './getEntityTrips';
+export * from './getEntityTripsCost';
+export * from './getInvitationRequest';
+export * from './getInvoicePdf';
+export * from './getInvoiceRefundableAmount';
+export * from './getInvoiceRefundNote';
+export * from './getOngoingTripNotes';
+export * from './getOngoingTrips';
+export * from './getStripePublishableKey';
+export * from './getStripeSetup';
+export * from './inviteBusinessUser';
+export * from './listBusinessUsersGlobal';
+export * from './redeemBusinessPromoCode';
+export * from './refundInvoice';
+export * from './refundInvoiceAmount';
+export * from './searchBusinessUsersByName';
+export * from './searchBusinessUsersGlobal';
+export * from './sendBusinessIban';
+export * from './setInvoiceExternalPayment';
+export * from './types';
+export * from './updateBusiness';
+export * from './updateBusinessCostCenter';
+export * from './updateBusinessProfileStatus';
+export * from './updateBusinessUserProfile';
+export * from './updateInvoiceStatus';

package/src/inviteBusinessUser.ts

@@ -0,0 +1,31 @@
+import { Client } from '@vulog/aima-client';
+import { z } from 'zod';
+
+export type InviteBusinessUserBody = {
+    email: string;
+    costCenterId?: string;
+};
+
+const inviteSchema = z.object({
+    businessId: z.string().trim().min(1).uuid(),
+    email: z.string().trim().email(),
+    costCenterId: z.string().trim().min(1).uuid().optional(),
+});
+
+export const inviteBusinessUser = async (
+    client: Client,
+    businessId: string,
+    body: InviteBusinessUserBody
+): Promise<void> => {
+    const result = inviteSchema.safeParse({ businessId, ...body });
+    if (!result.success) {
+        throw new TypeError('Invalid args', { cause: result.error.issues });
+    }
+
+    const { businessId: parsedId, ...parsedBody } = result.data;
+
+    await client.post<void>(
+        `/boapi/proxy/business/fleets/${client.clientOptions.fleetId}/business/${parsedId}/user/invite`,
+        parsedBody
+    );
+};

package/src/listBusinessUsersGlobal.test.ts

@@ -0,0 +1,65 @@
+import { describe, test, vi, expect, beforeEach } from 'vitest';
+import { Client } from '@vulog/aima-client';
+import { listBusinessUsersGlobal } from './listBusinessUsersGlobal';
+
+describe('listBusinessUsersGlobal', () => {
+    const postMock = vi.fn();
+    const client = {
+        post: postMock,
+        clientOptions: {
+            fleetId: 'FLEET_ID',
+        },
+    } as unknown as Client;
+
+    beforeEach(() => {
+        vi.clearAllMocks();
+    });
+
+    const USER_ID_1 = '018ab2b6-71b2-4c76-90bd-6e8d3f268618';
+    const USER_ID_2 = '550e8400-e29b-41d4-a716-446655440000';
+
+    test('should return business users for valid userIds', async () => {
+        const mockResponse = [
+            { userId: USER_ID_1, businessId: 'b1', role: 'ADMIN' },
+            { userId: USER_ID_2, businessId: 'b2', role: 'USER' },
+        ];
+        postMock.mockResolvedValueOnce({ data: mockResponse });
+
+        const result = await listBusinessUsersGlobal(client, { userIds: [USER_ID_1, USER_ID_2] });
+
+        expect(result).toEqual(mockResponse);
+        expect(postMock).toHaveBeenCalledWith(
+            '/boapi/proxy/business/fleets/FLEET_ID/users/list',
+            { userIds: [USER_ID_1, USER_ID_2] }
+        );
+    });
+
+    test('should throw for empty userIds array', async () => {
+        await expect(listBusinessUsersGlobal(client, { userIds: [] })).rejects.toThrow(TypeError);
+        expect(postMock).not.toHaveBeenCalled();
+    });
+
+    test('should throw for invalid UUIDs in array', async () => {
+        await expect(
+            listBusinessUsersGlobal(client, { userIds: ['not-a-uuid', 'also-bad'] })
+        ).rejects.toThrow(TypeError);
+        expect(postMock).not.toHaveBeenCalled();
+    });
+
+    test('should throw when array contains mix of valid and invalid UUIDs', async () => {
+        await expect(
+            listBusinessUsersGlobal(client, { userIds: [USER_ID_1, 'not-a-uuid'] })
+        ).rejects.toThrow(TypeError);
+        expect(postMock).not.toHaveBeenCalled();
+    });
+
+    test('error cause includes Zod issues', async () => {
+        try {
+            await listBusinessUsersGlobal(client, { userIds: [] });
+        } catch (err) {
+            expect(err).toBeInstanceOf(TypeError);
+            expect((err as Error).cause).toBeDefined();
+            expect(Array.isArray((err as Error).cause)).toBe(true);
+        }
+    });
+});

package/src/listBusinessUsersGlobal.ts

@@ -0,0 +1,26 @@
+import { Client } from '@vulog/aima-client';
+import { z } from 'zod';
+
+import { BusinessUser } from './types';
+
+export type ListBusinessUsersGlobalBody = {
+    userIds: string[];
+};
+
+const schema = z.object({
+    userIds: z.array(z.string().trim().min(1).uuid()).min(1),
+});
+
+export const listBusinessUsersGlobal = async (
+    client: Client,
+    body: ListBusinessUsersGlobalBody
+): Promise<BusinessUser[]> => {
+    const result = schema.safeParse(body);
+    if (!result.success) {
+        throw new TypeError('Invalid args', { cause: result.error.issues });
+    }
+
+    return client
+        .post<BusinessUser[]>(`/boapi/proxy/business/fleets/${client.clientOptions.fleetId}/users/list`, result.data)
+        .then(({ data }) => data);
+};

package/src/redeemBusinessPromoCode.ts

@@ -0,0 +1,18 @@
+import { Client } from '@vulog/aima-client';
+import { z } from 'zod';
+
+const schema = z.object({
+    businessId: z.string().trim().min(1).uuid(),
+    reference: z.string().trim().min(1),
+});
+
+export const redeemBusinessPromoCode = async (client: Client, businessId: string, reference: string): Promise<void> => {
+    const result = schema.safeParse({ businessId, reference });
+    if (!result.success) {
+        throw new TypeError('Invalid args', { cause: result.error.issues });
+    }
+
+    await client.post<void>(
+        `/boapi/proxy/business/fleets/${client.clientOptions.fleetId}/business/${result.data.businessId}/promoCodes/redeem/${result.data.reference}`
+    );
+};

package/src/refundInvoice.test.ts

@@ -0,0 +1,72 @@
+import { describe, test, vi, expect, beforeEach } from 'vitest';
+import { Client } from '@vulog/aima-client';
+import { refundInvoice } from './refundInvoice';
+
+describe('refundInvoice', () => {
+    const postMock = vi.fn();
+    const client = {
+        post: postMock,
+        clientOptions: { fleetId: 'FLEET_ID' },
+    } as unknown as Client;
+
+    const INVOICE_ID = '018ab2b6-71b2-4c76-90bd-6e8d3f268618';
+
+    beforeEach(() => {
+        vi.clearAllMocks();
+    });
+
+    test('should process refund with amount and note', async () => {
+        postMock.mockResolvedValueOnce({ data: undefined });
+
+        const result = await refundInvoice(client, INVOICE_ID, {
+            amount: 50,
+            note: 'Customer requested refund',
+        });
+
+        expect(result).toBeUndefined();
+        expect(postMock).toHaveBeenCalledWith(
+            `/boapi/proxy/business/fleets/FLEET_ID/invoices/${INVOICE_ID}/refund`,
+            { amount: 50, note: 'Customer requested refund' }
+        );
+    });
+
+    test('should process refund without body', async () => {
+        postMock.mockResolvedValueOnce({ data: undefined });
+
+        const result = await refundInvoice(client, INVOICE_ID);
+
+        expect(result).toBeUndefined();
+        expect(postMock).toHaveBeenCalledWith(
+            `/boapi/proxy/business/fleets/FLEET_ID/invoices/${INVOICE_ID}/refund`,
+            {}
+        );
+    });
+
+    test('should filter out undefined and null values', async () => {
+        postMock.mockResolvedValueOnce({ data: undefined });
+
+        await refundInvoice(client, INVOICE_ID, {
+            amount: 100,
+            note: null,
+        });
+
+        expect(postMock).toHaveBeenCalledWith(
+            `/boapi/proxy/business/fleets/FLEET_ID/invoices/${INVOICE_ID}/refund`,
+            { amount: 100 }
+        );
+    });
+
+    test('should throw for invalid invoiceId', async () => {
+        await expect(refundInvoice(client, 'not-a-uuid', { amount: 10 })).rejects.toThrow(TypeError);
+        expect(postMock).not.toHaveBeenCalled();
+    });
+
+    test('should throw for empty invoiceId', async () => {
+        await expect(refundInvoice(client, '', { amount: 10 })).rejects.toThrow(TypeError);
+        expect(postMock).not.toHaveBeenCalled();
+    });
+
+    test('should throw for negative amount', async () => {
+        await expect(refundInvoice(client, INVOICE_ID, { amount: -10 })).rejects.toThrow('Invalid args');
+    });
+});

package/src/refundInvoice.ts

@@ -0,0 +1,33 @@
+import { Client } from '@vulog/aima-client';
+import { z } from 'zod';
+
+export type RefundInvoiceBody = {
+    amount?: number;
+    note?: string | null;
+};
+
+const refundInvoiceBodySchema = z.object({
+    amount: z.number().min(0).optional(),
+    note: z.string().trim().nullable().optional(),
+});
+
+export const refundInvoice = async (client: Client, invoiceId: string, body?: RefundInvoiceBody): Promise<void> => {
+    const parsedId = z.string().trim().min(1).uuid().safeParse(invoiceId);
+    if (!parsedId.success) {
+        throw new TypeError('Invalid args', { cause: parsedId.error.issues });
+    }
+
+    const result = refundInvoiceBodySchema.safeParse(body ?? {});
+    if (!result.success) {
+        throw new TypeError('Invalid args', { cause: result.error.issues });
+    }
+
+    const filteredData = Object.fromEntries(
+        Object.entries(result.data).filter(([_, value]) => value !== undefined && value !== null)
+    );
+
+    await client.post<void>(
+        `/boapi/proxy/business/fleets/${client.clientOptions.fleetId}/invoices/${parsedId.data}/refund`,
+        filteredData
+    );
+};

package/src/refundInvoiceAmount.ts

@@ -0,0 +1,20 @@
+import { Client } from '@vulog/aima-client';
+import { z } from 'zod';
+
+const schema = z.object({
+    invoiceId: z.string().trim().min(1).uuid(),
+    amount: z.number().min(0),
+});
+
+/** @deprecated Use refundInvoice instead */
+export const refundInvoiceAmount = async (client: Client, invoiceId: string, amount: number): Promise<void> => {
+    const result = schema.safeParse({ invoiceId, amount });
+    if (!result.success) {
+        throw new TypeError('Invalid args', { cause: result.error.issues });
+    }
+
+    await client.post<void>(
+        `/boapi/proxy/business/fleets/${client.clientOptions.fleetId}/invoices/${result.data.invoiceId}/refund/${result.data.amount}`,
+        {}
+    );
+};

package/src/searchBusinessUsersByName.ts

@@ -0,0 +1,27 @@
+import { Client } from '@vulog/aima-client';
+import { z } from 'zod';
+
+import { BusinessUser } from './types';
+
+const searchSchema = z.object({
+    businessId: z.string().trim().min(1).uuid(),
+    name: z.string().trim().min(1),
+});
+
+export const searchBusinessUsersByName = async (
+    client: Client,
+    businessId: string,
+    name: string
+): Promise<BusinessUser[]> => {
+    const result = searchSchema.safeParse({ businessId, name });
+    if (!result.success) {
+        throw new TypeError('Invalid args', { cause: result.error.issues });
+    }
+
+    const searchParams = new URLSearchParams();
+    searchParams.append('name', result.data.name);
+
+    const url = `/boapi/proxy/business/fleets/${client.clientOptions.fleetId}/business/${result.data.businessId}/users/name?${searchParams.toString()}`;
+
+    return client.get<BusinessUser[]>(url).then(({ data }) => data);
+};

package/src/searchBusinessUsersGlobal.ts

@@ -0,0 +1,18 @@
+import { Client } from '@vulog/aima-client';
+import { z } from 'zod';
+
+import { BusinessUser } from './types';
+
+export const searchBusinessUsersGlobal = async (client: Client, query: string): Promise<BusinessUser[]> => {
+    const result = z.string().trim().min(1).safeParse(query);
+    if (!result.success) {
+        throw new TypeError('Invalid args', { cause: result.error.issues });
+    }
+
+    const searchParams = new URLSearchParams();
+    searchParams.append('query', result.data);
+
+    const url = `/boapi/proxy/business/fleets/${client.clientOptions.fleetId}/users/search?${searchParams.toString()}`;
+
+    return client.get<BusinessUser[]>(url).then(({ data }) => data);
+};

package/src/sendBusinessIban.ts

@@ -0,0 +1,29 @@
+import { Client } from '@vulog/aima-client';
+import { z } from 'zod';
+
+export type SendBusinessIbanBody = {
+    iban: string;
+};
+
+const schema = z.object({
+    businessId: z.string().trim().min(1).uuid(),
+    iban: z.string().trim().min(1),
+});
+
+export const sendBusinessIban = async (
+    client: Client,
+    businessId: string,
+    body: SendBusinessIbanBody
+): Promise<void> => {
+    const result = schema.safeParse({ businessId, ...body });
+    if (!result.success) {
+        throw new TypeError('Invalid args', { cause: result.error.issues });
+    }
+
+    const { businessId: parsedId, ...parsedBody } = result.data;
+
+    await client.post<void>(
+        `/boapi/proxy/business/fleets/${client.clientOptions.fleetId}/business/${parsedId}/paymentDetails/wireTransfer`,
+        parsedBody
+    );
+};

package/src/setInvoiceExternalPayment.ts

@@ -0,0 +1,33 @@
+import { Client } from '@vulog/aima-client';
+import { z } from 'zod';
+
+export type SetInvoiceExternalPaymentBody = {
+    paymentReference?: string;
+    paymentDate?: string;
+};
+
+const bodySchema = z.object({
+    paymentReference: z.string().trim().min(1).optional(),
+    paymentDate: z.string().trim().min(1).optional(),
+});
+
+export const setInvoiceExternalPayment = async (
+    client: Client,
+    invoiceId: string,
+    body: SetInvoiceExternalPaymentBody
+): Promise<void> => {
+    const parsedId = z.string().trim().min(1).uuid().safeParse(invoiceId);
+    if (!parsedId.success) {
+        throw new TypeError('Invalid args', { cause: parsedId.error.issues });
+    }
+
+    const result = bodySchema.safeParse(body);
+    if (!result.success) {
+        throw new TypeError('Invalid args', { cause: result.error.issues });
+    }
+
+    await client.put<void>(
+        `/boapi/proxy/business/fleets/${client.clientOptions.fleetId}/invoices/${parsedId.data}/externalPayment`,
+        result.data
+    );
+};