@vulog/aima-vehicle 1.2.5 → 1.2.7

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@vulog/aima-vehicle",
-    "version": "1.2.5",
+    "version": "1.2.7",
     "main": "dist/index.js",
     "module": "dist/index.mjs",
     "types": "dist/index.d.ts",
@@ -19,8 +19,8 @@
     "author": "Vulog",
     "license": "MIT",
     "dependencies": {
-        "@vulog/aima-client": "1.2.5",
-        "@vulog/aima-core": "1.2.5"
+        "@vulog/aima-client": "1.2.7",
+        "@vulog/aima-core": "1.2.7"
     },
     "peerDependencies": {
         "zod": "^3.25.76"

package/src/getModelVehicles.test.ts

@@ -0,0 +1,193 @@
+import { describe, test, vi, expect, beforeEach } from 'vitest';
+import { Client } from '@vulog/aima-client';
+import { getModelVehicles } from './getModelVehicles';
+import { ModelVehicle } from './types';
+
+describe('getModelVehicles', () => {
+    const getMock = vi.fn();
+    const client = {
+        get: getMock,
+        clientOptions: {
+            fleetId: 'FLEET_ID',
+        },
+    } as unknown as Client;
+
+    beforeEach(() => {
+        vi.clearAllMocks();
+    });
+
+    test('should return model vehicles with default options', async () => {
+        const mockData: ModelVehicle[] = [
+            {
+                serviceId: 'service-1',
+                serviceVisibility: 'PUBLIC',
+                modelId: 1,
+                vehicles: ['vehicle-1', 'vehicle-2'],
+            },
+            {
+                serviceId: 'service-2',
+                serviceVisibility: 'PRIVATE',
+                modelId: 2,
+                vehicles: ['vehicle-3'],
+            },
+        ];
+
+        const mockHeaders = {
+            number: 0,
+            size: 100,
+            totalelements: 2,
+            totalpages: 1,
+        };
+
+        getMock.mockResolvedValueOnce({
+            data: mockData,
+            headers: mockHeaders,
+        });
+
+        const result = await getModelVehicles(client);
+
+        expect(result).toEqual({
+            data: mockData,
+            page: 0,
+            pageSize: 100,
+            total: 2,
+            totalPages: 1,
+        });
+
+        expect(getMock).toHaveBeenCalledWith(
+            expect.stringContaining('boapi/proxy/user/vehicle/fleets/FLEET_ID/vehicles/models/modelvehicles')
+        );
+
+        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('pageSize')).toBe('100');
+        // sort is not provided in default options, so it should not be in URL
+        expect(url.searchParams.get('sort')).toBe(null);
+    });
+
+    test('should return model vehicles with custom options', async () => {
+        const mockData: ModelVehicle[] = [
+            {
+                serviceId: 'service-1',
+                serviceVisibility: 'PUBLIC',
+                modelId: 1,
+                vehicles: ['vehicle-1'],
+            },
+        ];
+
+        const mockHeaders = {
+            number: 1,
+            size: 50,
+            totalelements: 10,
+            totalpages: 1,
+        };
+
+        getMock.mockResolvedValueOnce({
+            data: mockData,
+            headers: mockHeaders,
+        });
+
+        const options = {
+            page: 1,
+            pageSize: 50,
+            sort: 'modelId',
+            sortDirection: 'DESC' as const,
+        };
+
+        const result = await getModelVehicles(client, options);
+
+        expect(result).toEqual({
+            data: mockData,
+            page: 1,
+            pageSize: 50,
+            total: 10,
+            totalPages: 1,
+        });
+
+        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('pageSize')).toBe('50');
+        expect(url.searchParams.get('sort')).toBe('modelId,DESC');
+    });
+
+    test('should handle default filters as empty object', async () => {
+        const mockData: ModelVehicle[] = [];
+        const mockHeaders = {
+            number: 0,
+            size: 100,
+            totalelements: 0,
+            totalpages: 0,
+        };
+
+        getMock.mockResolvedValueOnce({
+            data: mockData,
+            headers: mockHeaders,
+        });
+
+        const result = await getModelVehicles(client);
+
+        expect(result).toEqual({
+            data: mockData,
+            page: 0,
+            pageSize: 100,
+            total: 0,
+            totalPages: 0,
+        });
+
+        const calledUrl = getMock.mock.calls[0][0];
+        const url = new URL(calledUrl, 'http://example.com');
+        // Should only have page and pageSize parameters since sort and filters are not provided
+        expect(url.searchParams.toString()).toBe('page=0&pageSize=100');
+    });
+
+    test('should throw error for invalid page number', async () => {
+        const options = {
+            page: -1, // Invalid: negative page number
+        };
+
+        await expect(getModelVehicles(client, options)).rejects.toThrow('Invalid options');
+    });
+
+    test('should throw error for invalid page size', async () => {
+        const options = {
+            pageSize: 0, // Invalid: page size must be positive
+        };
+
+        await expect(getModelVehicles(client, options)).rejects.toThrow('Invalid options');
+    });
+
+    test('should throw error for invalid sort direction', async () => {
+        const options = {
+            sortDirection: 'INVALID' as any, // Invalid: not ASC or DESC
+        };
+
+        await expect(getModelVehicles(client, options)).rejects.toThrow('Invalid options');
+    });
+
+    test('should handle empty response', async () => {
+        const mockData: ModelVehicle[] = [];
+        const mockHeaders = {
+            number: 0,
+            size: 100,
+            totalelements: 0,
+            totalpages: 0,
+        };
+
+        getMock.mockResolvedValueOnce({
+            data: mockData,
+            headers: mockHeaders,
+        });
+
+        const result = await getModelVehicles(client);
+
+        expect(result).toEqual({
+            data: [],
+            page: 0,
+            pageSize: 100,
+            total: 0,
+            totalPages: 0,
+        });
+    });
+});

package/src/getModelVehicles.ts

@@ -0,0 +1,52 @@
+import { Client } from '@vulog/aima-client';
+import { PaginableOptions, PaginableResponse, createPaginableOptionsSchema } from '@vulog/aima-core';
+
+import { ModelVehicle } from './types';
+
+export const getModelVehicles = async (
+    client: Client,
+    options?: PaginableOptions
+): Promise<PaginableResponse<ModelVehicle>> => {
+    const PaginableOptionsSchema = createPaginableOptionsSchema().default({});
+
+    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('pageSize', finalOptions.pageSize!.toString());
+
+    // Handle optional sort parameter
+    if (finalOptions.sort) {
+        searchParams.append('sort', `${finalOptions.sort.toString()},${finalOptions.sortDirection!.toString()}`);
+    }
+
+    // Handle optional filters parameter
+    if (finalOptions.filters) {
+        Object.entries(finalOptions.filters).forEach(([key, value]) => {
+            if (value === undefined) {
+                return;
+            }
+            searchParams.append(key, value as string);
+        });
+    }
+
+    const basePath = `boapi/proxy/user/vehicle/fleets/${client.clientOptions.fleetId}/vehicles/models/modelvehicles`;
+    const urlWithParams = `${basePath}?${searchParams.toString()}`;
+
+    return client.get<ModelVehicle[]>(urlWithParams).then(({ data, headers }) => {
+        return {
+            data,
+            page: headers.number,
+            pageSize: headers.size,
+            total: headers.totalelements,
+            totalPages: headers.totalpages,
+        };
+    });
+};

package/src/index.ts

@@ -8,3 +8,4 @@ export * from './types';
 export * from './pingVehicle';
 export * from './enableVehicle';
 export * from './disableVehicle';
+export * from './getModelVehicles';

package/src/types.ts

@@ -221,3 +221,10 @@ export type Assets = {
     }[];
     [key: string]: any;
 };
+
+export type ModelVehicle = {
+    serviceId: string;
+    serviceVisibility: 'PUBLIC' | 'PRIVATE';
+    modelId: number;
+    vehicles: string[];
+};