@vulog/aima-booking 1.2.33 → 1.2.35

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,
+            });
+        });
+};

package/src/types.ts

@@ -225,3 +225,120 @@ export type AvailableVehiclesResponse = {
     stationId: string;
     vehicles: Vehicle[];
 };
+
+export type Slave = {
+    previous: string | null;
+    compositeStatus: string;
+    id: string;
+    startDate: string;
+    endDate: string;
+    profileId: string;
+    vehicleId: string;
+    modelId: number;
+    journeyId: string;
+    station: string;
+    status: string;
+    creationDate: string;
+    returnedDate: null;
+    serviceId: string;
+    pricingId: null;
+    plannedReturnDate: string | null;
+    cancellationDate: string | null;
+    rollingContract: boolean;
+    planDurationInMonths: number;
+    planName: string | null;
+    contractType: 'MVS' | 'SVS';
+    bookingReferenceId: string;
+};
+
+export interface IFormatSlave extends Slave {
+    traveledDistance: number | null;
+    realStartDate?: string | null;
+    cancellationRequestOutDTO?: {
+        status: string;
+        action: string;
+    };
+    manualApproval:
+        | {
+              status: string;
+              action: string;
+          }
+        | undefined;
+    from: 'ONGOING' | 'UPCOMING' | 'COMPLETED';
+}
+
+export type Master = {
+    bookingReferenceId: string;
+    cancellationDate: string | null;
+    cityId: string | null;
+    contractType: 'MVS' | 'SVS';
+    creationDate: string;
+    customPrice: number | null;
+    deliveryAddress: string | null;
+    deliveryAddressAdditionalInfo: string | null;
+    deliveryCity: string | null;
+    deliveryPostalCode: string | null;
+    endDate: string;
+    fleetId: string;
+    id: string;
+    journeyId: string;
+    modelId: number;
+    parentId: string;
+    planDurationInMonths: number;
+    planName: string;
+    plannedReturnDate: string | null;
+    pricingId: string | null;
+    previous: string | null;
+    products: string[];
+    profileId: string;
+    returnedDate: string | null;
+    rollingContract: boolean;
+    serviceId: string;
+    startDate: string;
+    station: string;
+    status: string;
+    vehicleId: string;
+    userId: string;
+};
+
+export interface IFormatSubscription extends Master {
+    slaves: {
+        ongoing: IFormatSlave[];
+        upcoming: IFormatSlave[];
+        completed: IFormatSlave[];
+    };
+    cancellationRequestStatus?: string;
+}
+
+export type Contract = {
+    id: string;
+    status: 'SIGNED';
+    provider: 'DOCUSIGN';
+    creationDate: string;
+    profileId: string;
+    externalContractId: string;
+    type: string;
+};
+
+export type AdditionalDriver = {
+    id: string;
+    fleetId: string;
+    bookingRequestId: string;
+    profileId: string;
+    updateDate: string;
+    invitationEmail: string;
+    profileStatus: string;
+    userId: string;
+};
+
+export type BookingRequestSlave = {
+    id: string;
+    vehicleId: string;
+    modelId: number;
+    startDate: string;
+    endDate: string;
+    tripId: string;
+    parentId: string;
+    traveledDistance: number;
+    energyLevelEnd: number;
+};