@vulog/aima-vehicle 1.2.29 → 1.2.31

package/dist/index.mjs

@@ -1,276 +1,216 @@
-// src/getModel.ts
-var getModelsById = async (client, id) => {
-  return client.get(`boapi/proxy/user/vehicle/fleets/${client.clientOptions.fleetId}/vehicles/models/${id}`).then(({ data }) => data);
+import z$1, { z } from "zod";
+import { createPaginableOptionsSchema } from "@vulog/aima-core";
+//#region src/getModel.ts
+const getModelsById = async (client, id) => {
+	return client.get(`boapi/proxy/user/vehicle/fleets/${client.clientOptions.fleetId}/vehicles/models/${id}`).then(({ data }) => data);
 };
-
-// src/getModelAssets.ts
-import { z } from "zod";
-var schema = z.object({
-  id: z.number().int().positive()
-});
-var getModelByIdAssets = async (client, id) => {
-  const result = schema.safeParse({ id });
-  if (!result.success) {
-    throw new TypeError("Invalid args", {
-      cause: result.error.issues
-    });
-  }
-  return client.get(`boapi/proxy/eds/rest_pub/rest/fleets/${client.clientOptions.fleetId}/models/${id}/`).then(({ data }) => data);
+//#endregion
+//#region src/getModelAssets.ts
+const schema$5 = z.object({ id: z.number().int().positive() });
+const getModelByIdAssets = async (client, id) => {
+	const result = schema$5.safeParse({ id });
+	if (!result.success) throw new TypeError("Invalid args", { cause: result.error.issues });
+	return client.get(`boapi/proxy/eds/rest_pub/rest/fleets/${client.clientOptions.fleetId}/models/${id}/`).then(({ data }) => data);
 };
-
-// src/getModels.ts
-var getModels = async (client) => {
-  return client.get(`boapi/proxy/user/vehicle/fleets/${client.clientOptions.fleetId}/vehicles/models`).then(({ data }) => data);
+//#endregion
+//#region src/getModels.ts
+const getModels = async (client) => {
+	return client.get(`boapi/proxy/user/vehicle/fleets/${client.clientOptions.fleetId}/vehicles/models`).then(({ data }) => data);
 };
-
-// src/getVehicle.ts
-import { z as z2 } from "zod";
-var schema2 = z2.object({
-  id: z2.string().trim().min(1).uuid()
-});
-var getVehicleById = async (client, id) => {
-  const result = schema2.safeParse({ id });
-  if (!result.success) {
-    throw new TypeError("Invalid args", {
-      cause: result.error.issues
-    });
-  }
-  return client.get(`boapi/proxy/user/vehicle/fleets/${client.clientOptions.fleetId}/vehicles/${result.data.id}`).then(({ data }) => data).catch((error) => {
-    if (error.formattedError?.status === 404) {
-      return null;
-    }
-    throw error;
-  });
+//#endregion
+//#region src/getVehicle.ts
+const schema$4 = z.object({ id: z.string().trim().min(1).uuid() });
+const getVehicleById = async (client, id) => {
+	const result = schema$4.safeParse({ id });
+	if (!result.success) throw new TypeError("Invalid args", { cause: result.error.issues });
+	return client.get(`boapi/proxy/user/vehicle/fleets/${client.clientOptions.fleetId}/vehicles/${result.data.id}`).then(({ data }) => data).catch((error) => {
+		if (error.formattedError?.status === 404) return null;
+		throw error;
+	});
 };
-var getVehicleRealTimeById = async (client, id) => {
-  const result = schema2.safeParse({ id });
-  if (!result.success) {
-    throw new TypeError("Invalid args", {
-      cause: result.error.issues
-    });
-  }
-  return client.get(
-    `boapi/proxy/fleetmanager/public/fleets/${client.clientOptions.fleetId}/vehicles/${result.data.id}`
-  ).then(({ data }) => data).catch((error) => {
-    if (error.formattedError?.status === 404) {
-      return null;
-    }
-    throw error;
-  });
+const getVehicleRealTimeById = async (client, id) => {
+	const result = schema$4.safeParse({ id });
+	if (!result.success) throw new TypeError("Invalid args", { cause: result.error.issues });
+	return client.get(`boapi/proxy/fleetmanager/public/fleets/${client.clientOptions.fleetId}/vehicles/${result.data.id}`).then(({ data }) => data).catch((error) => {
+		if (error.formattedError?.status === 404) return null;
+		throw error;
+	});
 };
-
-// src/getVehicleAssets.ts
-import { z as z3 } from "zod";
-var schema3 = z3.object({
-  id: z3.string().uuid()
-});
-var getVehicleByIdAssets = async (client, id) => {
-  const result = schema3.safeParse({ id });
-  if (!result.success) {
-    throw new TypeError("Invalid args", {
-      cause: result.error.issues
-    });
-  }
-  return client.get(`boapi/proxy/eds/rest_pub/rest/fleets/${client.clientOptions.fleetId}/vehicles/${id}/`).then(({ data }) => data);
+//#endregion
+//#region src/getVehicleAssets.ts
+const schema$3 = z.object({ id: z.string().uuid() });
+const getVehicleByIdAssets = async (client, id) => {
+	const result = schema$3.safeParse({ id });
+	if (!result.success) throw new TypeError("Invalid args", { cause: result.error.issues });
+	return client.get(`boapi/proxy/eds/rest_pub/rest/fleets/${client.clientOptions.fleetId}/vehicles/${id}/`).then(({ data }) => data);
 };
-
-// src/getVehicles.ts
-import { z as z4 } from "zod";
-var getVehiclesPage = async (client, page, pageSize) => {
-  const response = await client.get(
-    `boapi/proxy/user/vehicle/fleets/${client.clientOptions.fleetId}/vehicles?page=${page}&size=${pageSize}`
-  );
-  return response.data;
+//#endregion
+//#region src/getVehicles.ts
+/**
+* Fetches a single page of vehicles from the API
+* @param client - The AIMA client instance
+* @param page - The page number to fetch
+* @param pageSize - Number of vehicles per page
+* @returns Promise that resolves to an array of vehicles for the requested page
+*/
+const getVehiclesPage = async (client, page, pageSize) => {
+	return (await client.get(`boapi/proxy/user/vehicle/fleets/${client.clientOptions.fleetId}/vehicles?page=${page}&size=${pageSize}`)).data;
 };
-var getVehicles = async (client, pageSize = 500) => {
-  const schema7 = z4.object({
-    pageSize: z4.number().min(1).default(500)
-  });
-  const result = schema7.safeParse({ pageSize });
-  if (!result.success) {
-    throw new TypeError("Invalid args", {
-      cause: result.error.issues
-    });
-  }
-  const allVehicles = [];
-  let currentPage = 0;
-  let hasMorePages = true;
-  const MAX_PAGES = 50;
-  while (hasMorePages) {
-    if (currentPage >= MAX_PAGES) {
-      throw new Error(
-        `Maximum page limit (${MAX_PAGES}) reached. This might indicate an issue with the pagination or a very large dataset.`
-      );
-    }
-    const vehicles = await getVehiclesPage(client, currentPage, result.data.pageSize);
-    allVehicles.push(...vehicles);
-    hasMorePages = vehicles.length === result.data.pageSize;
-    currentPage += 1;
-  }
-  return allVehicles;
+/**
+* Fetches all vehicles from the API using pagination
+* @param client - The AIMA client instance
+* @param pageSize - Number of vehicles per page (default: 500)
+* @returns Promise that resolves to an array of all vehicles
+* @throws Error if more than 50 pages are required to fetch all vehicles
+*/
+const getVehicles = async (client, pageSize = 500) => {
+	const result = z.object({ pageSize: z.number().min(1).default(500) }).safeParse({ pageSize });
+	if (!result.success) throw new TypeError("Invalid args", { cause: result.error.issues });
+	const allVehicles = [];
+	let currentPage = 0;
+	let hasMorePages = true;
+	const MAX_PAGES = 50;
+	while (hasMorePages) {
+		if (currentPage >= MAX_PAGES) throw new Error(`Maximum page limit (${MAX_PAGES}) reached. This might indicate an issue with the pagination or a very large dataset.`);
+		const vehicles = await getVehiclesPage(client, currentPage, result.data.pageSize);
+		allVehicles.push(...vehicles);
+		hasMorePages = vehicles.length === result.data.pageSize;
+		currentPage += 1;
+	}
+	return allVehicles;
 };
-var getVehiclesRealTimePage = async (client, page, pageSize, lastUpdatedMillis) => {
-  const queryParams = new URLSearchParams({
-    page: page.toString(),
-    size: pageSize.toString()
-  });
-  if (lastUpdatedMillis !== void 0) {
-    queryParams.append("lastUpdatedMillis", lastUpdatedMillis.toString());
-  }
-  const response = await client.get(
-    `boapi/proxy/fleetmanager/public/fleets/${client.clientOptions.fleetId}/vehicles?${queryParams.toString()}`
-  );
-  return response.data;
+/**
+* Fetches a single page of real-time vehicle data from the API
+* @param client - The AIMA client instance
+* @param page - The page number to fetch
+* @param pageSize - Number of vehicles per page
+* @param lastUpdatedMillis - Optional timestamp in UTC milliseconds
+* @returns Promise that resolves to an array of real-time vehicle data for the requested page
+*/
+const getVehiclesRealTimePage = async (client, page, pageSize, lastUpdatedMillis) => {
+	const queryParams = new URLSearchParams({
+		page: page.toString(),
+		size: pageSize.toString()
+	});
+	if (lastUpdatedMillis !== void 0) queryParams.append("lastUpdatedMillis", lastUpdatedMillis.toString());
+	return (await client.get(`boapi/proxy/fleetmanager/public/fleets/${client.clientOptions.fleetId}/vehicles?${queryParams.toString()}`)).data;
 };
-var getVehiclesRealTime = async (client, pageSize = 500, lastUpdatedMillis) => {
-  const schema7 = z4.object({
-    pageSize: z4.number().min(1).default(500),
-    lastUpdatedMillis: z4.number().positive().optional()
-  });
-  const result = schema7.safeParse({ pageSize, lastUpdatedMillis });
-  if (!result.success) {
-    throw new TypeError("Invalid args", {
-      cause: result.error.issues
-    });
-  }
-  const allVehicles = [];
-  let currentPage = 0;
-  let hasMorePages = true;
-  const MAX_PAGES = 50;
-  if (lastUpdatedMillis !== void 0) {
-    const now = Date.now();
-    if (lastUpdatedMillis > now) {
-      throw new Error("lastUpdatedMillis must be in the past");
-    }
-  }
-  while (hasMorePages) {
-    if (currentPage >= MAX_PAGES) {
-      throw new Error(
-        `Maximum page limit (${MAX_PAGES}) reached. This might indicate an issue with the pagination or a very large dataset.`
-      );
-    }
-    const vehicles = await getVehiclesRealTimePage(
-      client,
-      currentPage,
-      result.data.pageSize,
-      result.data.lastUpdatedMillis
-    );
-    allVehicles.push(...vehicles);
-    hasMorePages = vehicles.length === result.data.pageSize;
-    currentPage += 1;
-  }
-  return allVehicles;
+/**
+* Fetches all real-time vehicle data from the API using pagination
+* @param client - The AIMA client instance
+* @param pageSize - Number of vehicles per page (default: 500)
+* @param lastUpdatedMillis - Optional timestamp in UTC milliseconds. If provided, only vehicles updated after this timestamp will be returned.
+* @returns Promise that resolves to an array of all real-time vehicle data
+* @throws Error if more than 50 pages are required to fetch all vehicles
+* @throws Error if lastUpdatedMillis is in the future
+*/
+const getVehiclesRealTime = async (client, pageSize = 500, lastUpdatedMillis) => {
+	const result = z.object({
+		pageSize: z.number().min(1).default(500),
+		lastUpdatedMillis: z.number().positive().optional()
+	}).safeParse({
+		pageSize,
+		lastUpdatedMillis
+	});
+	if (!result.success) throw new TypeError("Invalid args", { cause: result.error.issues });
+	const allVehicles = [];
+	let currentPage = 0;
+	let hasMorePages = true;
+	const MAX_PAGES = 50;
+	if (lastUpdatedMillis !== void 0) {
+		if (lastUpdatedMillis > Date.now()) throw new Error("lastUpdatedMillis must be in the past");
+	}
+	while (hasMorePages) {
+		if (currentPage >= MAX_PAGES) throw new Error(`Maximum page limit (${MAX_PAGES}) reached. This might indicate an issue with the pagination or a very large dataset.`);
+		const vehicles = await getVehiclesRealTimePage(client, currentPage, result.data.pageSize, result.data.lastUpdatedMillis);
+		allVehicles.push(...vehicles);
+		hasMorePages = vehicles.length === result.data.pageSize;
+		currentPage += 1;
+	}
+	return allVehicles;
 };
-
-// src/pingVehicle.ts
-import { z as z5 } from "zod";
-var schema4 = z5.object({
-  id: z5.string().trim().min(1).uuid()
-});
-var pingVehicleById = async (client, id) => {
-  const result = schema4.safeParse({ id });
-  if (!result.success) {
-    throw new TypeError("Invalid args", {
-      cause: result.error.issues
-    });
-  }
-  try {
-    await client.get(
-      `boapi/proxy/fleetmanager/public/v2/fleets/${client.clientOptions.fleetId}/vehicles/${result.data.id}/ping`
-    );
-    return true;
-  } catch (error) {
-    if (error?.response?.data?.codeStr === "carConnectionProblem" && error?.response?.data?.code === 410) {
-      return false;
-    }
-    throw error;
-  }
+//#endregion
+//#region src/pingVehicle.ts
+const schema$2 = z.object({ id: z.string().trim().min(1).uuid() });
+/**
+* Pings a vehicle to check if it is alive (box connected).
+* Returns true if alive (HTTP 200), false if box not connected (code 410, codeStr 'carConnectionProblem'),
+* throws for other errors or invalid id.
+*/
+const pingVehicleById = async (client, id) => {
+	const result = schema$2.safeParse({ id });
+	if (!result.success) throw new TypeError("Invalid args", { cause: result.error.issues });
+	try {
+		await client.get(`boapi/proxy/fleetmanager/public/v2/fleets/${client.clientOptions.fleetId}/vehicles/${result.data.id}/ping`);
+		return true;
+	} catch (error) {
+		if (error?.response?.data?.codeStr === "carConnectionProblem" && error?.response?.data?.code === 410) return false;
+		throw error;
+	}
 };
-
-// src/enableVehicle.ts
-import z6 from "zod";
-var schema5 = z6.object({
-  subStatus: z6.string()
-});
-var enableVehicle = async (client, vehicleId, payload) => {
-  const result = schema5.safeParse(payload);
-  if (!result.success) {
-    throw new TypeError("Invalid args", {
-      cause: result.error.issues
-    });
-  }
-  return client.post(
-    `boapi/proxy/fleetmanager/public/fleets/${client.clientOptions.fleetId}/vehicles/${vehicleId}/enable`,
-    payload
-  ).then(({ data }) => data);
+//#endregion
+//#region src/enableVehicle.ts
+const schema$1 = z$1.object({ subStatus: z$1.string() });
+const enableVehicle = async (client, vehicleId, payload) => {
+	const result = schema$1.safeParse(payload);
+	if (!result.success) throw new TypeError("Invalid args", { cause: result.error.issues });
+	return client.post(`boapi/proxy/fleetmanager/public/fleets/${client.clientOptions.fleetId}/vehicles/${vehicleId}/enable`, payload).then(({ data }) => data);
 };
-
-// src/disableVehicle.ts
-import z7 from "zod";
-var schema6 = z7.object({
-  subStatus: z7.string()
-});
-var disableVehicle = async (client, vehicleId, payload) => {
-  const result = schema6.safeParse(payload);
-  if (!result.success) {
-    throw new TypeError("Invalid args", {
-      cause: result.error.issues
-    });
-  }
-  return client.post(
-    `boapi/proxy/fleetmanager/public/fleets/${client.clientOptions.fleetId}/vehicles/${vehicleId}/disable`,
-    payload
-  ).then(({ data }) => data);
+//#endregion
+//#region src/disableVehicle.ts
+const schema = z$1.object({ subStatus: z$1.string() });
+const disableVehicle = async (client, vehicleId, payload) => {
+	const result = schema.safeParse(payload);
+	if (!result.success) throw new TypeError("Invalid args", { cause: result.error.issues });
+	return client.post(`boapi/proxy/fleetmanager/public/fleets/${client.clientOptions.fleetId}/vehicles/${vehicleId}/disable`, payload).then(({ data }) => data);
 };
-
-// src/getModelVehicles.ts
-import { createPaginableOptionsSchema } from "@vulog/aima-core";
-var getModelVehicles = async (client, options) => {
-  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("size", finalOptions.pageSize.toString());
-  if (finalOptions.sort) {
-    searchParams.append("sort", `${finalOptions.sort.toString()},${finalOptions.sortDirection.toString()}`);
-  }
-  if (finalOptions.filters) {
-    Object.entries(finalOptions.filters).forEach(([key, value]) => {
-      if (value === void 0) {
-        return;
-      }
-      searchParams.append(key, value);
-    });
-  }
-  const basePath = `boapi/proxy/user/vehicle/fleets/${client.clientOptions.fleetId}/vehicles/models/modelvehicles`;
-  const urlWithParams = `${basePath}?${searchParams.toString()}`;
-  return client.get(urlWithParams).then(({ data, headers }) => {
-    return {
-      data,
-      page: headers.number,
-      pageSize: headers.size,
-      total: headers.totalelements,
-      totalPages: headers.totalpages
-    };
-  });
+//#endregion
+//#region src/getModelVehicles.ts
+const getModelVehicles = async (client, options) => {
+	const resultOptions = createPaginableOptionsSchema().default({}).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()}`);
+	if (finalOptions.filters) Object.entries(finalOptions.filters).forEach(([key, value]) => {
+		if (value === void 0) return;
+		searchParams.append(key, value);
+	});
+	const urlWithParams = `${`boapi/proxy/user/vehicle/fleets/${client.clientOptions.fleetId}/vehicles/models/modelvehicles`}?${searchParams.toString()}`;
+	return client.get(urlWithParams).then(({ data, headers }) => {
+		return {
+			data,
+			page: headers.number,
+			pageSize: headers.size,
+			total: headers.totalelements,
+			totalPages: headers.totalpages
+		};
+	});
 };
-export {
-  disableVehicle,
-  enableVehicle,
-  getModelByIdAssets,
-  getModelVehicles,
-  getModels,
-  getModelsById,
-  getVehicleById,
-  getVehicleByIdAssets,
-  getVehicleRealTimeById,
-  getVehicles,
-  getVehiclesRealTime,
-  pingVehicleById
+//#endregion
+//#region src/createVehicle.ts
+const createVehicleBodySchema = z.object({
+	vin: z.string().trim().min(1).max(20),
+	plate: z.string().trim().min(1).max(16),
+	name: z.string().trim().min(1).max(64),
+	model: z.object({ id: z.number().int().positive() }),
+	vuboxId: z.string().optional(),
+	externalId: z.string().max(32).optional(),
+	wakeupProvider: z.string().max(16).optional(),
+	noBox: z.boolean().optional(),
+	published: z.boolean().optional(),
+	archived: z.boolean().optional(),
+	msisdn: z.string().max(32).optional(),
+	iccid: z.string().max(32).optional(),
+	imsi: z.string().max(32).optional(),
+	residualValue: z.number().optional()
+});
+const createVehicle = async (client, body) => {
+	const result = createVehicleBodySchema.safeParse(body);
+	if (!result.success) throw new TypeError("Invalid args", { cause: result.error.issues });
+	return client.post(`/boapi/proxy/vehicle/fleets/${client.clientOptions.fleetId}/vehicles`, result.data).then(({ data }) => data);
 };
+//#endregion
+export { createVehicle, disableVehicle, enableVehicle, getModelByIdAssets, getModelVehicles, getModels, getModelsById, getVehicleById, getVehicleByIdAssets, getVehicleRealTimeById, getVehicles, getVehiclesRealTime, pingVehicleById };

package/package.json

@@ -1,12 +1,25 @@
 {
     "name": "@vulog/aima-vehicle",
-    "version": "1.2.29",
-    "main": "dist/index.js",
+    "type": "module",
+    "version": "1.2.31",
+    "main": "dist/index.cjs",
     "module": "dist/index.mjs",
-    "types": "dist/index.d.ts",
+    "types": "dist/index.d.cts",
+    "exports": {
+        ".": {
+            "import": {
+                "types": "./dist/index.d.mts",
+                "default": "./dist/index.mjs"
+            },
+            "require": {
+                "types": "./dist/index.d.cts",
+                "default": "./dist/index.cjs"
+            }
+        }
+    },
     "scripts": {
-        "build": "tsup",
-        "dev": "tsup --watch",
+        "build": "tsdown",
+        "dev": "tsdown --watch",
         "test": "vitest run",
         "test:watch": "vitest",
         "lint": "eslint src/**/* --ext .ts"
@@ -19,8 +32,8 @@
     "author": "Vulog",
     "license": "MIT",
     "dependencies": {
-        "@vulog/aima-client": "1.2.29",
-        "@vulog/aima-core": "1.2.29"
+        "@vulog/aima-client": "1.2.31",
+        "@vulog/aima-core": "1.2.31"
     },
     "peerDependencies": {
         "zod": "^3.25.76"

package/src/createVehicle.test.ts

@@ -0,0 +1,88 @@
+import { describe, test, vi, expect, beforeEach } from 'vitest';
+import { Client } from '@vulog/aima-client';
+import { createVehicle, CreateVehicleBody } from './createVehicle';
+
+describe('createVehicle', () => {
+    const postMock = vi.fn();
+    const client = {
+        post: postMock,
+        clientOptions: {
+            fleetId: 'FLEET_ID',
+        },
+    } as unknown as Client;
+
+    beforeEach(() => {
+        vi.clearAllMocks();
+    });
+
+    const validBody: CreateVehicleBody = {
+        vin: '1HGBH41JXMN109186',
+        plate: 'AB-123-CD',
+        name: 'Test Vehicle',
+        model: { id: 1 },
+    };
+
+    test('should create a vehicle with required fields only', async () => {
+        const mockResponse = { id: 'vehicle-uuid', ...validBody };
+        postMock.mockResolvedValueOnce({ data: mockResponse });
+
+        const result = await createVehicle(client, validBody);
+
+        expect(result).toEqual(mockResponse);
+        expect(postMock).toHaveBeenCalledWith(
+            '/boapi/proxy/vehicle/fleets/FLEET_ID/vehicles',
+            validBody
+        );
+    });
+
+    test('should create a vehicle with optional fields', async () => {
+        const fullBody: CreateVehicleBody = {
+            ...validBody,
+            vuboxId: 'vubox-123',
+            externalId: 'ext-123',
+            wakeupProvider: 'provider',
+            noBox: true,
+            published: true,
+            archived: false,
+            msisdn: '33600000000',
+            iccid: '8933000000000000000',
+            imsi: '208000000000000',
+            residualValue: 15000,
+        };
+        const mockResponse = { id: 'vehicle-uuid', ...fullBody };
+        postMock.mockResolvedValueOnce({ data: mockResponse });
+
+        const result = await createVehicle(client, fullBody);
+
+        expect(result).toEqual(mockResponse);
+        expect(postMock).toHaveBeenCalledWith(
+            '/boapi/proxy/vehicle/fleets/FLEET_ID/vehicles',
+            fullBody
+        );
+    });
+
+    test('should throw for missing vin', async () => {
+        const body = { ...validBody, vin: '' };
+        await expect(createVehicle(client, body)).rejects.toThrow(TypeError);
+    });
+
+    test('should throw for missing plate', async () => {
+        const body = { ...validBody, plate: '' };
+        await expect(createVehicle(client, body)).rejects.toThrow(TypeError);
+    });
+
+    test('should throw for missing name', async () => {
+        const body = { ...validBody, name: '' };
+        await expect(createVehicle(client, body)).rejects.toThrow(TypeError);
+    });
+
+    test('should throw for invalid model id', async () => {
+        const body = { ...validBody, model: { id: -1 } };
+        await expect(createVehicle(client, body)).rejects.toThrow(TypeError);
+    });
+
+    test('should throw for missing model', async () => {
+        const body = { vin: 'VIN123', plate: 'AB-123', name: 'Test' } as CreateVehicleBody;
+        await expect(createVehicle(client, body)).rejects.toThrow(TypeError);
+    });
+});