@vulog/aima-booking 1.2.34 → 1.2.35

package/src/getAdditionalDrivers.ts

@@ -0,0 +1,23 @@
+import { Client } from '@vulog/aima-client';
+import { z } from 'zod';
+
+import { type AdditionalDriver } from './types';
+
+const schema = z.object({
+    parentId: z.string().trim().min(1),
+});
+
+export const getAdditionalDrivers = async (client: Client, parentId: string): Promise<AdditionalDriver[]> => {
+    const result = schema.safeParse({ parentId });
+    if (!result.success) {
+        throw new TypeError('Invalid parentId', {
+            cause: result.error.issues,
+        });
+    }
+
+    return client
+        .get<
+            AdditionalDriver[]
+        >(`/boapi/proxy/user/fleets/${client.clientOptions.fleetId}/bookingrequests/${parentId}/additionalDrivers`)
+        .then(({ data }) => data);
+};

package/src/getAvailableVehicles.test.ts

@@ -0,0 +1,53 @@
+import { describe, test, expect, vi, beforeEach } from 'vitest';
+import { Client } from '@vulog/aima-client';
+import { getAvailableVehicles } from './getAvailableVehicles';
+
+describe('getAvailableVehicles', () => {
+    const getMock = vi.fn();
+    const client = {
+        get: getMock,
+        clientOptions: {
+            fleetId: 'FLEET_ID',
+        },
+    } as unknown as Client;
+
+    beforeEach(() => {
+        getMock.mockReset();
+    });
+
+    test('throws Invalid args when stationId is empty', async () => {
+        await expect(
+            getAvailableVehicles(client, '', '2025-02-10T12:00:00Z')
+        ).rejects.toThrow(TypeError);
+        await expect(
+            getAvailableVehicles(client, '', '2025-02-10T12:00:00Z')
+        ).rejects.toMatchObject({ message: 'Invalid args' });
+        expect(getMock).not.toHaveBeenCalled();
+    });
+
+    test('throws Invalid args when startDate is invalid datetime', async () => {
+        await expect(
+            getAvailableVehicles(client, 'station-123', 'not-a-date')
+        ).rejects.toThrow(TypeError);
+        expect(getMock).not.toHaveBeenCalled();
+    });
+
+    test('calls GET with correct URL and returns available vehicles response', async () => {
+        const stationId = 'ded03b86-fa3f-4d79-80fa-191b2ec13b5e';
+        const startDate = '2025-02-10T12:00:00Z';
+        const response = {
+            stationId,
+            vehicles: [{ vehicleId: 'vehicle-1' }, { vehicleId: 'vehicle-2' }],
+        };
+        getMock.mockResolvedValueOnce({ data: response });
+
+        const result = await getAvailableVehicles(client, stationId, startDate);
+
+        expect(getMock).toHaveBeenCalledTimes(1);
+        expect(getMock).toHaveBeenCalledWith(
+            `/boapi/proxy/user/scheduledBooking/fleets/FLEET_ID/subscription/stations/${stationId}/vehicles/available?startDate=${startDate}`
+        );
+        expect(result).toEqual(response);
+        expect(result.vehicles).toHaveLength(2);
+    });
+});

package/src/getBookingRequest.test.ts

@@ -1,5 +1,10 @@
 import { describe, test, expect, vi, beforeEach, afterEach } from 'vitest';
-import { getBookingRequestById, getBookingRequestByTrip, getSubscriptionBookingRequestById } from './getBookingRequest';
+import {
+    getBookingRequestById,
+    getBookingRequestByTrip,
+    getSubscriptionBookingRequestById,
+    getScheduledBookingById,
+} from './getBookingRequest';
 import { Client } from '@vulog/aima-client';
 import { randomUUID } from 'crypto';
 import { PaymentReceipts } from './types';
@@ -436,3 +441,69 @@ describe('getsubscriptionBookingRequestByID', () => {
         expect(result.station).toEqual(data.stationId);
     });
 });
+
+describe('getScheduledBookingById', () => {
+    const getMock = vi.fn();
+    const client = {
+        get: getMock,
+        clientOptions: {
+            fleetId: 'FLEET_ID',
+        },
+    } as unknown as Client;
+
+    beforeEach(() => {
+        getMock.mockReset();
+    });
+
+    test('throws Invalid bookingId when bookingId is not a valid UUID', async () => {
+        await expect(getScheduledBookingById(client, 'not-a-uuid')).rejects.toThrow(TypeError);
+        await expect(getScheduledBookingById(client, 'not-a-uuid')).rejects.toMatchObject({
+            message: 'Invalid bookingId',
+        });
+        expect(getMock).not.toHaveBeenCalled();
+    });
+
+    test('throws Invalid bookingId when bookingId is empty', async () => {
+        await expect(getScheduledBookingById(client, '')).rejects.toThrow(TypeError);
+        expect(getMock).not.toHaveBeenCalled();
+    });
+
+    test('calls GET with by-service URL and returns SATBookingRequest', async () => {
+        const bookingId = randomUUID();
+        const data = {
+            id: bookingId,
+            startDate: '2026-03-03T10:00:00Z',
+            endDate: '2026-06-03T09:00:00Z',
+            returnedDate: null,
+            profileId: '76175b0c-7e39-41ad-a338-914df3a5fdf6',
+            vehicleId: null,
+            modelId: null,
+            journeyId: 'BEBD00056A9A16103D418CC36D940E26',
+            station: 'ded03b86-fa3f-4d79-80fa-191b2ec13b5e',
+            status: 'CONFIRMED',
+            creationDate: '2026-03-03T09:29:45Z',
+            fleetId: 'FLEET_ID',
+            userId: '20fb98a3-b60d-491a-9359-62e55f51fcb9',
+            serviceId: 'f49080b0-66bc-45e9-8e84-0dfb57bb8f92',
+            productIds: [],
+            pricingDetails: [],
+            completed: true,
+            rollingContract: true,
+            planDurationInMonths: 3,
+            planName: '3 mois',
+            contractType: 'SVS',
+            bookingReferenceId: 'q93UCF',
+        };
+        getMock.mockResolvedValueOnce({ data });
+
+        const result = await getScheduledBookingById(client, bookingId);
+
+        expect(getMock).toHaveBeenCalledTimes(1);
+        expect(getMock).toHaveBeenCalledWith(
+            `/boapi/proxy/user/scheduledBooking/by-service/fleets/FLEET_ID/bookingrequests/${bookingId}`
+        );
+        expect(result).toEqual(data);
+        expect(result.id).toBe(bookingId);
+        expect(result.status).toBe('CONFIRMED');
+    });
+});

package/src/getBookingRequest.ts

@@ -1,7 +1,7 @@
 import { Client } from '@vulog/aima-client';
 import { z } from 'zod';
 
-import { BookingRequest } from './types';
+import { BookingRequest, SATBookingRequest } from './types';
 
 export const getBookingRequestById = async (client: Client, id: string): Promise<BookingRequest> => {
     const result = z.string().trim().min(1).uuid().safeParse(id);
@@ -46,3 +46,17 @@ export const getSubscriptionBookingRequestById = async (client: Client, id: stri
         )
         .then(({ data: { stationId, ...data } }) => ({ station: stationId, ...data }) as BookingRequest);
 };
+
+export const getScheduledBookingById = async (client: Client, bookingId: string): Promise<SATBookingRequest> => {
+    const result = z.string().trim().min(1).uuid().safeParse(bookingId);
+    if (!result.success) {
+        throw new TypeError('Invalid bookingId', {
+            cause: result.error.issues,
+        });
+    }
+    return client
+        .get<SATBookingRequest>(
+            `/boapi/proxy/user/scheduledBooking/by-service/fleets/${client.clientOptions.fleetId}/bookingrequests/${bookingId}`
+        )
+        .then(({ data }) => data);
+};

package/src/getDigitalContracts.test.ts

@@ -0,0 +1,72 @@
+import { describe, test, expect, vi, beforeEach } from 'vitest';
+import { Client } from '@vulog/aima-client';
+import { getDigitalContracts } from './getDigitalContracts';
+import type { Contract } from './types';
+
+describe('getDigitalContracts', () => {
+    const getMock = vi.fn();
+    const client = {
+        get: getMock,
+        clientOptions: {
+            fleetId: 'FLEET_ID',
+        },
+    } as unknown as Client;
+
+    const mockContracts: Contract[] = [
+        {
+            id: 'contract-1',
+            status: 'SIGNED',
+            provider: 'DOCUSIGN',
+            creationDate: '2026-03-03T10:00:00Z',
+            profileId: '76175b0c-7e39-41ad-a338-914df3a5fdf6',
+            externalContractId: 'ext-1',
+            type: 'RENTAL',
+        },
+    ];
+
+    beforeEach(() => {
+        getMock.mockReset();
+    });
+
+    test('throws Invalid args when bookingId is empty', async () => {
+        await expect(getDigitalContracts(client, '')).rejects.toThrow(TypeError);
+        await expect(getDigitalContracts(client, '')).rejects.toMatchObject({
+            message: 'Invalid args',
+        });
+        expect(getMock).not.toHaveBeenCalled();
+    });
+
+    test('calls GET with default status SIGNED and returns contracts', async () => {
+        const bookingId = '66bcbd77-37ef-47bd-b9af-877e5d213b8f';
+        getMock.mockResolvedValueOnce({ data: mockContracts });
+
+        const result = await getDigitalContracts(client, bookingId);
+
+        expect(getMock).toHaveBeenCalledTimes(1);
+        expect(getMock).toHaveBeenCalledWith(
+            `/boapi/proxy/user/scheduledBooking/fleets/FLEET_ID/subscription/bookingrequests/${bookingId}/digitalContracts?status=SIGNED`
+        );
+        expect(result).toEqual(mockContracts);
+        expect(result[0].status).toBe('SIGNED');
+    });
+
+    test('calls GET with custom status when provided', async () => {
+        const bookingId = '66bcbd77-37ef-47bd-b9af-877e5d213b8f';
+        getMock.mockResolvedValueOnce({ data: [] });
+
+        await getDigitalContracts(client, bookingId, 'PENDING');
+
+        expect(getMock).toHaveBeenCalledWith(
+            `/boapi/proxy/user/scheduledBooking/fleets/FLEET_ID/subscription/bookingrequests/${bookingId}/digitalContracts?status=PENDING`
+        );
+    });
+
+    test('returns empty array when no contracts', async () => {
+        const bookingId = 'some-booking-id';
+        getMock.mockResolvedValueOnce({ data: [] });
+
+        const result = await getDigitalContracts(client, bookingId);
+
+        expect(result).toEqual([]);
+    });
+});

package/src/getDigitalContracts.ts

@@ -0,0 +1,26 @@
+import { Client } from '@vulog/aima-client';
+import { z } from 'zod';
+
+import { Contract } from './types';
+
+const schema = z.object({
+    bookingId: z.string().trim().min(1),
+});
+
+export const getDigitalContracts = async (
+    client: Client,
+    bookingId: string,
+    status = 'SIGNED'
+): Promise<Contract[]> => {
+    const result = schema.safeParse({ bookingId });
+    if (!result.success) {
+        throw new TypeError('Invalid args', {
+            cause: result.error.issues,
+        });
+    }
+    return client
+        .get<
+            Contract[]
+        >(`/boapi/proxy/user/scheduledBooking/fleets/${client.clientOptions.fleetId}/subscription/bookingrequests/${result.data.bookingId}/digitalContracts?status=${encodeURIComponent(status)}`)
+        .then(({ data }) => data);
+};

package/src/getSlaves.test.ts

@@ -0,0 +1,60 @@
+import { describe, test, expect, vi, beforeEach } from 'vitest';
+import { Client } from '@vulog/aima-client';
+import { randomUUID } from 'crypto';
+import { getSlaves } from './getSlaves';
+import type { BookingRequestSlave } from './types';
+
+describe('getSlaves', () => {
+    const getMock = vi.fn();
+    const client = {
+        get: getMock,
+        clientOptions: {
+            fleetId: 'FLEET_ID',
+        },
+    } as unknown as Client;
+
+    beforeEach(() => {
+        getMock.mockReset();
+    });
+
+    test('throws Invalid bookingId when parentId is empty', async () => {
+        await expect(getSlaves(client, '', 'UPCOMING')).rejects.toThrow(TypeError);
+        await expect(getSlaves(client, '', 'UPCOMING')).rejects.toMatchObject({
+            message: 'Invalid bookingId',
+        });
+        expect(getMock).not.toHaveBeenCalled();
+    });
+
+    test('throws when status is not in enum', async () => {
+        const parentId = randomUUID();
+        await expect(getSlaves(client, parentId, 'INVALID_STATUS')).rejects.toThrow(TypeError);
+        expect(getMock).not.toHaveBeenCalled();
+    });
+
+    test('calls GET with correct URL for UPCOMING and returns slaves', async () => {
+        const parentId = randomUUID();
+        const slaves: BookingRequestSlave[] = [
+            {
+                id: randomUUID(),
+                vehicleId: randomUUID(),
+                modelId: 2597,
+                startDate: '2026-03-03T10:00:00Z',
+                endDate: '2026-03-06T09:00:00Z',
+                tripId: 'BEBD00056A9A16103D418CC36D940E26',
+                parentId,
+                traveledDistance: 120,
+                energyLevelEnd: 80,
+            },
+        ];
+        getMock.mockResolvedValueOnce({ data: slaves });
+
+        const result = await getSlaves(client, parentId, 'UPCOMING');
+
+        expect(getMock).toHaveBeenCalledTimes(1);
+        expect(getMock).toHaveBeenCalledWith(
+            `/boapi/proxy/user/scheduledBooking/fleets/FLEET_ID/subscription/bookingRequests/${parentId}/bookingRequestsSlave?bookingStatus=UPCOMING`
+        );
+        expect(result).toEqual(slaves);
+        expect(result).toHaveLength(1);
+    });
+});

package/src/getSlaves.ts

@@ -0,0 +1,24 @@
+import { Client } from '@vulog/aima-client';
+import { z } from 'zod';
+
+import { BookingRequestSlave } from './types';
+
+const schema = z.object({
+    parentId: z.string().trim().min(1),
+    status: z.enum(['ONGOING, COMPLETED', 'UPCOMING']),
+});
+
+export const getSlaves = async (client: Client, parentId: string, status: string): Promise<BookingRequestSlave[]> => {
+    const result = schema.safeParse({ parentId, status });
+    if (!result.success) {
+        throw new TypeError('Invalid bookingId', {
+            cause: result.error.issues,
+        });
+    }
+
+    return client
+        .get<
+            BookingRequestSlave[]
+        >(`/boapi/proxy/user/scheduledBooking/fleets/${client.clientOptions.fleetId}/subscription/bookingRequests/${parentId}/bookingRequestsSlave?bookingStatus=${status}`)
+        .then(({ data }) => data);
+};

package/src/getSubscriptionsByUserId.test.ts

@@ -0,0 +1,96 @@
+import { describe, test, expect, vi, beforeEach } from 'vitest';
+import { Client } from '@vulog/aima-client';
+import { randomUUID } from 'crypto';
+import { getSubscriptionsByUserId } from './getSubscriptionsByUserId';
+import type { Master } from './types';
+
+describe('getSubscriptionsByUserId', () => {
+    const getMock = vi.fn();
+    const client = {
+        get: getMock,
+        clientOptions: {
+            fleetId: 'FLEET_ID',
+        },
+    } as unknown as Client;
+
+    beforeEach(() => {
+        getMock.mockReset();
+    });
+
+    test('throws Invalid userId when userId is not a valid UUID', async () => {
+        await expect(getSubscriptionsByUserId(client, 'not-a-uuid')).rejects.toThrow(TypeError);
+        await expect(getSubscriptionsByUserId(client, 'not-a-uuid')).rejects.toMatchObject({
+            message: 'Invalid userId',
+        });
+        expect(getMock).not.toHaveBeenCalled();
+    });
+
+    test('calls GET with active path by default and returns masters', async () => {
+        const userId = randomUUID();
+        const masters: Master[] = [
+            {
+                id: randomUUID(),
+                fleetId: 'FLEET_ID',
+                userId,
+                bookingReferenceId: 'q93UCF',
+                startDate: '2026-03-03T10:00:00Z',
+                endDate: '2026-06-03T09:00:00Z',
+                creationDate: '2026-03-03T09:29:45Z',
+                status: 'CONFIRMED',
+                contractType: 'SVS',
+                station: 'ded03b86-fa3f-4d79-80fa-191b2ec13b5e',
+                vehicleId: randomUUID(),
+                modelId: 2597,
+                journeyId: 'BEBD00056A9A16103D418CC36D940E26',
+                profileId: randomUUID(),
+                serviceId: randomUUID(),
+                planDurationInMonths: 3,
+                planName: '3 mois',
+                rollingContract: true,
+                returnedDate: null,
+                cancellationDate: null,
+                cityId: null,
+                customPrice: null,
+                deliveryAddress: null,
+                deliveryAddressAdditionalInfo: null,
+                deliveryCity: null,
+                deliveryPostalCode: null,
+                plannedReturnDate: null,
+                parentId: randomUUID(),
+                previous: null,
+                pricingId: null,
+                products: [],
+            },
+        ];
+        getMock.mockResolvedValueOnce({ data: masters });
+
+        const result = await getSubscriptionsByUserId(client, userId);
+
+        expect(getMock).toHaveBeenCalledTimes(1);
+        expect(getMock).toHaveBeenCalledWith(
+            `/boapi/proxy/user/scheduledBooking/fleets/FLEET_ID/subscription/users/${userId}/active`
+        );
+        expect(result).toEqual(masters);
+        expect(result).toHaveLength(1);
+    });
+
+    test('calls GET with past path when active is false', async () => {
+        const userId = randomUUID();
+        getMock.mockResolvedValueOnce({ data: [] });
+
+        await getSubscriptionsByUserId(client, userId, false);
+
+        expect(getMock).toHaveBeenCalledWith(
+            `/boapi/proxy/user/scheduledBooking/fleets/FLEET_ID/subscription/users/${userId}/past`
+        );
+    });
+
+    test('returns empty array when no subscriptions', async () => {
+        const userId = randomUUID();
+        getMock.mockResolvedValueOnce({ data: [] });
+
+        const result = await getSubscriptionsByUserId(client, userId);
+
+        expect(result).toEqual([]);
+    });
+});

package/src/getSubscriptionsByUserId.ts

@@ -0,0 +1,27 @@
+import { Client } from '@vulog/aima-client';
+import { z } from 'zod';
+
+import { Master } from './types';
+
+const schema = z.object({
+    userId: z.string().trim().min(1).uuid(),
+    active: z.boolean().optional().default(true),
+});
+
+export const getSubscriptionsByUserId = async (
+    client: Client,
+    userId: string,
+    active: boolean = true
+): Promise<Master[]> => {
+    const result = schema.safeParse({ userId, active });
+    if (!result.success) {
+        throw new TypeError('Invalid userId', {
+            cause: result.error.issues,
+        });
+    }
+    return client
+        .get<
+            Master[]
+        >(`/boapi/proxy/user/scheduledBooking/fleets/${client.clientOptions.fleetId}/subscription/users/${userId}/${active ? 'active' : 'past'}`)
+        .then(({ data }) => data);
+};

package/src/index.ts

@@ -1,6 +1,11 @@
 export { getBookingRequests, getScheduleBookingRequests, getSubscriptionBookingRequests } from './getBookingRequests';
 export { getSATBookingRequests } from './getSATBookingRequests';
-export { getBookingRequestById, getBookingRequestByTrip, getSubscriptionBookingRequestById } from './getBookingRequest';
+export {
+    getBookingRequestById,
+    getBookingRequestByTrip,
+    getSubscriptionBookingRequestById,
+    getScheduledBookingById,
+} from './getBookingRequest';
 export * from './types';
 export type { BookingRequestStatus, ServiceType, BookingRequestFilters } from './getBookingRequests';
 export type { SATBookingRequestStatus } from './getSATBookingRequests';
@@ -16,5 +21,10 @@ export { triggerBRPayment } from './triggerBRPayment';
 export { getBookingRequestsByUserId } from './getBookingRequestsByUserId';
 export { releaseBRPayment } from './releaseBRPayment';
 export { cancelBookingRequest } from './cancelBookingRequest';
+export { getDigitalContracts } from './getDigitalContracts';
+export { getAdditionalDrivers } from './getAdditionalDrivers';
+export { getSlaves } from './getSlaves';
+export { getSubscriptionsByUserId } from './getSubscriptionsByUserId';
+export { submitCancellationRequest } from './submitCancellationRequest';
 export { createSubscription } from './createSubscription';
 export type { CreateSubscriptionBody } from './createSubscription';

package/src/submitCancellationRequest.test.ts

@@ -0,0 +1,81 @@
+import { describe, test, expect, vi, beforeEach } from 'vitest';
+import { Client } from '@vulog/aima-client';
+import { randomUUID } from 'crypto';
+import { submitCancellationRequest } from './submitCancellationRequest';
+import type { SATBookingRequest } from './types';
+
+describe('submitCancellationRequest', () => {
+    const postMock = vi.fn();
+    const client = {
+        post: postMock,
+        clientOptions: {
+            fleetId: 'FLEET_ID',
+        },
+    } as unknown as Client;
+
+    const minimalResponse = {
+        id: randomUUID(),
+        status: 'PENDING',
+        startDate: '2026-03-03T10:00:00Z',
+        endDate: '2026-06-03T09:00:00Z',
+        fleetId: 'FLEET_ID',
+        userId: randomUUID(),
+        profileId: randomUUID(),
+        serviceId: randomUUID(),
+        creationDate: '2026-03-03T09:29:45Z',
+        productIds: [],
+        pricingDetails: [],
+        completed: false,
+        rollingContract: true,
+        contractType: 'SVS',
+        notes: '',
+    } as unknown as SATBookingRequest;
+
+    beforeEach(() => {
+        postMock.mockReset();
+    });
+
+    test('throws Invalid args when bookingRequestId is not a valid UUID', async () => {
+        const userId = randomUUID();
+        await expect(
+            submitCancellationRequest(client, 'not-a-uuid', userId)
+        ).rejects.toThrow(TypeError);
+        await expect(
+            submitCancellationRequest(client, 'not-a-uuid', userId)
+        ).rejects.toMatchObject({ message: 'Invalid args' });
+        expect(postMock).not.toHaveBeenCalled();
+    });
+
+    test('calls POST with correct URL and body and returns SATBookingRequest', async () => {
+        const bookingRequestId = randomUUID();
+        const userId = randomUUID();
+        postMock.mockResolvedValueOnce({ data: minimalResponse });
+
+        const result = await submitCancellationRequest(client, bookingRequestId, userId);
+
+        expect(postMock).toHaveBeenCalledTimes(1);
+        expect(postMock).toHaveBeenCalledWith(
+            `/boapi/proxy/user/fleets/FLEET_ID/bookingrequests/${bookingRequestId}/actions`,
+            {
+                action: 'EARLIER_CANCELLATION_REQUEST',
+                bookingStatusBO: 'ONGOING',
+                status: 'PENDING',
+                userId,
+            }
+        );
+        expect(result).toEqual(minimalResponse);
+    });
+
+    test('throws when request fails', async () => {
+        const bookingRequestId = randomUUID();
+        const userId = randomUUID();
+        const networkError = new Error('Network error');
+        postMock.mockRejectedValueOnce(networkError);
+
+        await expect(
+            submitCancellationRequest(client, bookingRequestId, userId)
+        ).rejects.toMatchObject({
+            message: 'Failed to submit cancellation request',
+        });
+    });
+});

package/src/submitCancellationRequest.ts

@@ -0,0 +1,38 @@
+import { Client } from '@vulog/aima-client';
+import { z } from 'zod';
+
+import { SATBookingRequest } from './types';
+
+const schema = z.object({
+    bookingRequestId: z.string().uuid(),
+    userId: z.string().uuid(),
+});
+
+export const submitCancellationRequest = async (
+    client: Client,
+    bookingRequestId: string,
+    userId: string
+): Promise<SATBookingRequest> => {
+    const result = schema.safeParse({ bookingRequestId, userId });
+    if (!result.success) {
+        throw new TypeError('Invalid args', {
+            cause: result.error.issues,
+        });
+    }
+    return client
+        .post<SATBookingRequest>(
+            `/boapi/proxy/user/fleets/${client.clientOptions.fleetId}/bookingrequests/${bookingRequestId}/actions`,
+            {
+                action: 'EARLIER_CANCELLATION_REQUEST',
+                bookingStatusBO: 'ONGOING',
+                status: 'PENDING',
+                userId,
+            }
+        )
+        .then(({ data }) => data)
+        .catch((error) => {
+            throw new TypeError('Failed to submit cancellation request', {
+                cause: error,
+            });
+        });
+};