@vulog/aima-booking 1.2.30 → 1.2.32

package/dist/index.cjs

@@ -0,0 +1,465 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+//#region \0rolldown/runtime.js
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+//#endregion
+let _vulog_aima_core = require("@vulog/aima-core");
+let es_toolkit_compat = require("es-toolkit/compat");
+let zod = require("zod");
+zod = __toESM(zod);
+//#region src/getBookingRequests.ts
+const BookingRequestStatusSchema = zod.z.enum([
+	"ALERT",
+	"UPCOMING",
+	"ONGOING",
+	"COMPLETED",
+	"CANCELLED",
+	"PENDING_APPROVAL",
+	"CONFIRMED",
+	"PENDING",
+	"LATE"
+]);
+const ServiceTypeSchema = zod.z.enum([
+	"SUBSCRIPTION",
+	"ROUND_TRIP_BOOKING",
+	"SCHEDULED_BOOKING_STATION"
+]);
+const getBookingRequests = async (client, status, options) => {
+	const preparedOptions = options ? {
+		...options,
+		filters: options.filters || {}
+	} : { filters: {} };
+	const resultStatus = BookingRequestStatusSchema.safeParse(status);
+	if (!resultStatus.success) throw new TypeError("Invalid status", { cause: resultStatus.error.issues });
+	const date = /* @__PURE__ */ new Date();
+	date.setMilliseconds(0);
+	const startDate = date.toISOString().replace(".000Z", "Z");
+	date.setMonth(date.getMonth() + 2);
+	const endDate = date.toISOString().replace(".000Z", "Z");
+	const resultOptions = (0, _vulog_aima_core.createPaginableOptionsSchema)(zod.z.object({
+		serviceTypes: zod.z.array(ServiceTypeSchema).optional(),
+		serviceIds: zod.z.array(zod.z.string().uuid()).optional(),
+		userId: zod.z.string().uuid().optional(),
+		modelId: zod.z.number().positive().optional(),
+		vehicleId: zod.z.string().uuid().optional(),
+		stationId: zod.z.string().uuid().optional(),
+		creationDate: zod.z.string().date().optional(),
+		startDate: zod.z.string().datetime({
+			offset: false,
+			precision: 0
+		}).default(startDate),
+		endDate: zod.z.string().datetime({
+			offset: false,
+			precision: 0
+		}).default(endDate),
+		includeProducts: zod.z.enum(["true", "false"]).optional()
+	}).default({})).default({}).safeParse(preparedOptions);
+	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());
+	Object.entries(finalOptions.filters).forEach(([key, value]) => {
+		if (value === void 0) return;
+		if (Array.isArray(value) && value.length > 0) {
+			searchParams.append(key, value.join(","));
+			return;
+		}
+		if ((0, es_toolkit_compat.isNumber)(value)) {
+			searchParams.append(key, value.toString());
+			return;
+		}
+		searchParams.append(key, value);
+	});
+	return client.get(`/boapi/proxy/user/scheduledBooking/fleets/${client.clientOptions.fleetId}/bookingrequests/status/${status}/filters?${searchParams.toString()}`).then(({ data, headers }) => {
+		return {
+			data,
+			page: headers.number,
+			pageSize: headers.size,
+			total: headers.totalelements,
+			totalPages: headers.totalpages
+		};
+	});
+};
+const getScheduleBookingRequests = async (client, status, options) => {
+	return getBookingRequests(client, status, {
+		...options,
+		filters: {
+			...options?.filters,
+			serviceTypes: ["ROUND_TRIP_BOOKING", "SCHEDULED_BOOKING_STATION"]
+		}
+	});
+};
+const getSubscriptionBookingRequests = async (client, status, options) => {
+	return getBookingRequests(client, status, {
+		...options,
+		filters: {
+			...options?.filters,
+			serviceTypes: ["SUBSCRIPTION"]
+		}
+	});
+};
+//#endregion
+//#region src/getSATBookingRequests.ts
+const SATBookingRequestStatusSchema = zod.z.enum([
+	"ALERT",
+	"CANCELLED",
+	"COMPLETED",
+	"CONFIRMED",
+	"LATE_RETURN",
+	"ONGOING",
+	"PENDING_PAYMENT",
+	"PENDING",
+	"UPCOMING_ALLOCATED",
+	"UPCOMING_NOT_ALLOCATED"
+]);
+const getSATBookingRequests = async (client, status, options) => {
+	const resultStatus = SATBookingRequestStatusSchema.safeParse(status);
+	if (!resultStatus.success) throw new TypeError("Invalid status", { cause: resultStatus.error.issues });
+	const resultOptions = (0, _vulog_aima_core.createPaginableOptionsSchema)().default({}).safeParse(options);
+	if (!resultOptions.success) throw new TypeError("Invalid options", { cause: resultOptions.error.issues });
+	const finalOptions = resultOptions.data;
+	const searchParams = new URLSearchParams();
+	if (finalOptions.page) searchParams.append("page", finalOptions.page.toString());
+	if (finalOptions.pageSize) searchParams.append("size", finalOptions.pageSize.toString());
+	if (finalOptions.sortDirection && finalOptions.sort) searchParams.append("sort", `${finalOptions.sort},${finalOptions.sortDirection}`);
+	if (finalOptions.sort && !finalOptions.sortDirection) searchParams.append("sort", finalOptions.sort);
+	return client.get(`/boapi/proxy/user/scheduleATrip/fleets/${client.clientOptions.fleetId}/bookingrequests/status/${status}?${searchParams.toString()}`).then(({ data, headers }) => {
+		return {
+			data,
+			page: headers.number,
+			pageSize: headers.size,
+			total: headers.totalelements,
+			totalPages: headers.totalpages
+		};
+	});
+};
+//#endregion
+//#region src/getBookingRequest.ts
+const getBookingRequestById = async (client, id) => {
+	const result = zod.z.string().trim().min(1).uuid().safeParse(id);
+	if (!result.success) throw new TypeError("Invalid id", { cause: result.error.issues });
+	return client.get(`/boapi/proxy/user/scheduledBooking/fleets/${client.clientOptions.fleetId}/bookingrequests/${id}`).then(({ data }) => data);
+};
+const getBookingRequestByTrip = async (client, tripId) => {
+	const result = zod.z.string().trim().min(1).safeParse(tripId);
+	if (!result.success) throw new TypeError("Invalid tripId", { cause: result.error.issues });
+	return client.get(`/boapi/proxy/user/scheduledBooking/fleets/${client.clientOptions.fleetId}/bookingrequests/trip/${tripId}`).then(({ data }) => data);
+};
+const getSubscriptionBookingRequestById = async (client, id) => {
+	const result = zod.z.string().trim().min(1).uuid().safeParse(id);
+	if (!result.success) throw new TypeError("Invalid id", { cause: result.error.issues });
+	return client.get(`/boapi/proxy/user/scheduledBooking/fleets/${client.clientOptions.fleetId}/subscription/bookingrequests/${id}`).then(({ data: { stationId, ...data } }) => ({
+		station: stationId,
+		...data
+	}));
+};
+//#endregion
+//#region src/getAvailableVehicles.ts
+/** ISO date-time without milliseconds (e.g. 2025-02-10T12:00:00Z or 2025-02-10T12:00:00+01:00). */
+const isoDateTimeNoMs = zod.z.string().trim().datetime({ precision: 0 });
+const getAvailableVehiclesSchema = zod.z.object({
+	stationId: zod.z.string().trim().min(1),
+	startDate: isoDateTimeNoMs
+});
+const getAvailableVehicles = async (client, stationId, startDate) => {
+	const result = getAvailableVehiclesSchema.safeParse({
+		stationId,
+		startDate
+	});
+	if (!result.success) throw new TypeError("Invalid args", { cause: result.error.issues });
+	return client.get(`/boapi/proxy/user/scheduledBooking/fleets/${client.clientOptions.fleetId}/subscription/stations/${stationId}/vehicles/available?startDate=${startDate}`).then(({ data }) => data);
+};
+//#endregion
+//#region src/getStations.ts
+const IncludeSchema$1 = zod.z.enum([
+	"INFO",
+	"OPEN_HOUR",
+	"SERVICES"
+]);
+const IncludesSchema$1 = zod.z.array(IncludeSchema$1);
+const getStations = async (client, includes = []) => {
+	const resultIncludes = IncludesSchema$1.safeParse(includes);
+	if (!resultIncludes.success) throw new TypeError("Invalid includes", { cause: resultIncludes.error.issues });
+	const searchParams = new URLSearchParams();
+	if (includes.includes("OPEN_HOUR")) searchParams.append("showTimetable", "true");
+	const stations = await client.get(`/boapi/proxy/user/scheduledBooking/fleets/${client.clientOptions.fleetId}/stations${searchParams.size > 0 ? `?${searchParams.toString()}` : ""}`).then(({ data }) => data.map((station) => Object.keys(station).reduce((acc, key) => {
+		if (key === "stationTimetableDTO") {
+			if (station.stationTimetableDTO?.stationId) acc.openingHours = {
+				alwaysOpen: station.stationTimetableDTO.alwaysOpen,
+				timetable: Object.keys(station.stationTimetableDTO.timetable).reduce((timetable, val) => {
+					timetable[val] = station.stationTimetableDTO.timetable[val].map((day) => ({
+						id: day.id,
+						closed: day.closed,
+						openAt: day.openAt,
+						closeAt: day.closeAt
+					}));
+					return timetable;
+				}, {})
+			};
+			return acc;
+		}
+		acc[key] = station[key];
+		return acc;
+	}, {})));
+	if (includes.includes("INFO")) {
+		const pois = await client.get(`/boapi/proxy/geoloc/fleets/${client.clientOptions.fleetId}/pois`, { headers: { accept: "application/vnd.geo+json" } }).then(({ data }) => data.features.reduce((acc, poi) => {
+			const { geometry: { coordinates: [longitude, latitude] }, properties } = poi;
+			acc[properties.poiId] = {
+				name: properties.name,
+				coordinates: {
+					latitude,
+					longitude
+				},
+				geoProperties: properties
+			};
+			return acc;
+		}, {}));
+		stations.forEach((station) => {
+			if (station.poiId && pois[station.poiId]) Object.assign(station, pois[station.poiId]);
+		});
+	}
+	if (includes.includes("SERVICES")) {
+		const services = await client.get(`/boapi/proxy/user/fleets/${client.clientOptions.fleetId}/stations/details?size=1000`).then(({ data }) => data.stations.reduce((acc, service) => {
+			if (!acc[service.station.id]) acc[service.station.id] = { services: [] };
+			acc[service.station.id].services.push({
+				id: service.serviceId,
+				models: service.station.models
+			});
+			return acc;
+		}, {}));
+		stations.forEach((station) => {
+			if (services[station.id]) Object.assign(station, services[station.id]);
+		});
+	}
+	return stations;
+};
+//#endregion
+//#region src/getStation.ts
+const IncludeSchema = zod.z.enum(["INFO", "SERVICES"]);
+const IncludesSchema = zod.z.array(IncludeSchema);
+const getStationById = async (client, id, includes = []) => {
+	const resultIncludes = IncludesSchema.safeParse(includes);
+	if (!resultIncludes.success) throw new TypeError("Invalid includes", { cause: resultIncludes.error.issues });
+	const station = await client.get(`/boapi/proxy/user/scheduledBooking/fleets/${client.clientOptions.fleetId}/stations/${id}`).then(({ data, status }) => {
+		if (status === 200) return Object.keys(data).reduce((acc, key) => {
+			if (key === "stationTimetableDTO") {
+				if (data.stationTimetableDTO?.stationId) acc.openingHours = {
+					alwaysOpen: data.stationTimetableDTO.alwaysOpen,
+					timetable: Object.keys(data.stationTimetableDTO.timetable).reduce((timetable, val) => {
+						timetable[val] = data.stationTimetableDTO.timetable[val].map((day) => ({
+							id: day.id,
+							closed: day.closed,
+							openAt: day.openAt,
+							closeAt: day.closeAt
+						}));
+						return timetable;
+					}, {})
+				};
+				return acc;
+			}
+			acc[key] = data[key];
+			return acc;
+		}, {});
+		if (status === 400) return null;
+		return null;
+	}).catch((error) => {
+		if (error.formattedError?.status === 400) return null;
+		throw error;
+	});
+	if (station && includes.includes("INFO")) {
+		const poi = await client.get(`/boapi/proxy/geoloc/fleets/${client.clientOptions.fleetId}/pois/${station.poiId}`, { headers: { accept: "application/vnd.geo+json" } }).then(({ data }) => data.features.reduce((max, current) => {
+			if (current.properties.Version > max.version) {
+				const { geometry: { coordinates: [longitude, latitude] }, properties } = current;
+				return {
+					version: current.properties.Version,
+					name: properties.name,
+					coordinates: {
+						latitude,
+						longitude
+					},
+					geoProperties: properties
+				};
+			}
+			return max;
+		}, { version: -1 }));
+		if (station.poiId && poi) {
+			poi.version = void 0;
+			Object.assign(station, poi);
+			station.name = station.geoProperties?.name;
+		}
+	}
+	if (station && includes.includes("SERVICES")) {
+		const services = await client.get(`/boapi/proxy/user/fleets/${client.clientOptions.fleetId}/stations/details?showTimetable=false`).then(({ data }) => data.stations.reduce((acc, service) => {
+			if (!acc[service.station.id]) acc[service.station.id] = { services: [] };
+			acc[service.station.id].services.push({
+				id: service.serviceId,
+				models: service.station.models
+			});
+			return acc;
+		}, {}));
+		if (services[station.id]) Object.assign(station, services[station.id]);
+	}
+	return station;
+};
+//#endregion
+//#region src/allocateVehicle.ts
+const allocateVehicleSchema = zod.default.object({
+	bookingRequestId: zod.default.string().uuid(),
+	vehicleId: zod.default.string().uuid(),
+	serviceId: zod.default.string().uuid()
+});
+const allocateVehicle = async (client, bookingRequestId, vehicleId, serviceId) => {
+	const resultPayload = allocateVehicleSchema.safeParse({
+		bookingRequestId,
+		vehicleId,
+		serviceId
+	});
+	if (!resultPayload.success) throw new TypeError("Invalid args", { cause: resultPayload.error.issues });
+	return client.post(`boapi/proxy/user/scheduleATrip/fleets/${client.clientOptions.fleetId}/bookingrequests/${bookingRequestId}/allocate/${vehicleId}?serviceId=${serviceId}`).then(({ data }) => data);
+};
+//#endregion
+//#region src/deallocateVehicle.ts
+const deallocateVehicleSchema = zod.default.object({
+	bookingRequestId: zod.default.string().uuid(),
+	vehicleId: zod.default.string().uuid()
+});
+const deallocateVehicle = async (client, bookingRequestId, vehicleId) => {
+	const resultPayload = deallocateVehicleSchema.safeParse({
+		bookingRequestId,
+		vehicleId
+	});
+	if (!resultPayload.success) throw new TypeError("Invalid args", { cause: resultPayload.error.issues });
+	return client.delete(`boapi/proxy/user/scheduledBooking/fleets/${client.clientOptions.fleetId}/bookingrequests/${bookingRequestId}/vehicles/${vehicleId}`).then(({ data }) => data);
+};
+//#endregion
+//#region src/updateScheduleBooking.ts
+const schema$2 = zod.default.object({
+	id: zod.default.string(),
+	startDate: zod.default.string().refine((date) => !Number.isNaN(Date.parse(date)), { message: "Invalid date" }).optional(),
+	latitude: zod.default.number().min(-90).max(90).optional(),
+	longitude: zod.default.number().min(-180).max(180).optional(),
+	radius: zod.default.number().min(0).optional(),
+	userId: zod.default.string().optional(),
+	status: zod.default.enum([
+		"CONFIRMED",
+		"CANCELLED",
+		"PENDING"
+	]).optional(),
+	cityId: zod.default.string().optional(),
+	profileId: zod.default.string().optional(),
+	serviceId: zod.default.string().optional(),
+	warning: zod.default.string().optional(),
+	modelId: zod.default.number().optional(),
+	notes: zod.default.string().optional(),
+	bookingReferenceId: zod.default.string().optional(),
+	plannedReturnDate: zod.default.string().refine((date) => !Number.isNaN(Date.parse(date)), { message: "Invalid date" }).optional()
+});
+const updateScheduleBooking = async (client, bookingRequestId, updateData) => {
+	const result = schema$2.safeParse({
+		id: bookingRequestId,
+		...updateData
+	});
+	if (!result.success) throw new TypeError("Invalid args", { cause: result.error.issues });
+	return client.post(`/boapi/proxy/user/scheduleATrip/fleets/${client.clientOptions.fleetId}/bookingrequests/${bookingRequestId}`, updateData).then(({ data }) => data);
+};
+//#endregion
+//#region src/triggerBRPayment.ts
+const triggerBRPaymentSchema = zod.default.object({
+	bookingRequestId: zod.default.string().uuid(),
+	body: zod.default.object({
+		scope: zod.default.enum(["RENTAL", "DEPOSIT"]),
+		requiresActionReturnURL: zod.default.string().url().optional(),
+		online: zod.default.boolean(),
+		amountType: zod.default.enum(["FIXED", "PERCENTAGE"]),
+		amountValue: zod.default.number().nonnegative(),
+		preferredPaymentMethods: zod.default.array(zod.default.object({
+			pspReference: zod.default.string(),
+			amount: zod.default.number().default(0)
+		})).optional(),
+		profileId: zod.default.string().uuid()
+	})
+});
+const triggerBRPayment = async (client, bookingRequestId, body) => {
+	const resultPayload = triggerBRPaymentSchema.safeParse({
+		bookingRequestId,
+		body
+	});
+	if (!resultPayload.success) throw new TypeError("Invalid args", { cause: resultPayload.error.issues });
+	return client.post(`boapi/proxy/user/scheduledBooking/fleets/${client.clientOptions.fleetId}/bookingrequests/${bookingRequestId}/payment`, resultPayload.data.body).then(({ data }) => data).catch((error) => {
+		throw new TypeError("Failed to trigger booking request payment", { cause: error });
+	});
+};
+//#endregion
+//#region src/getBookingRequestsByUserId.ts
+const schema$1 = zod.z.object({ userId: zod.z.string().trim().min(1).uuid() });
+const getBookingRequestsByUserId = async (client, userId) => {
+	const result = schema$1.safeParse({ userId });
+	if (!result.success) throw new TypeError("Invalid userId", { cause: result.error.issues });
+	return client.get(`/user/scheduledBooking/fleets/${client.clientOptions.fleetId}/bookingrequests/users/${userId}`).then(({ data }) => data).catch((error) => {
+		if (error.formattedError?.status === 404) return [];
+		throw error;
+	});
+};
+//#endregion
+//#region src/releaseBRPayment.ts
+const releaseBRPaymentSchema = zod.default.object({
+	bookingRequestId: zod.default.string().uuid(),
+	pspReference: zod.default.string().uuid()
+});
+const releaseBRPayment = async (client, bookingRequestId, pspReference) => {
+	const resultPayload = releaseBRPaymentSchema.safeParse({
+		bookingRequestId,
+		pspReference
+	});
+	if (!resultPayload.success) throw new TypeError("Invalid args", { cause: resultPayload.error.issues });
+	return client.post(`boapi/proxy/user/scheduledBooking/fleets/${client.clientOptions.fleetId}/bookingrequests/${bookingRequestId}/paymentintent/${pspReference}/cancel`, {}).then(({ data }) => data).catch((error) => {
+		throw new TypeError("Failed to release booking request payment", { cause: error });
+	});
+};
+//#endregion
+//#region src/cancelBookingRequest.ts
+const schema = zod.default.object({ id: zod.default.string().uuid() });
+const cancelBookingRequest = async (client, id) => {
+	const result = schema.safeParse({ id });
+	if (!result.success) throw new TypeError("Invalid args", { cause: result.error.issues });
+	return client.post(`/boapi/proxy/user/scheduledBooking/fleets/${client.clientOptions.fleetId}/bookingrequests/cancel/${id}`, {}).then(({ data }) => data).catch((error) => {
+		throw new TypeError("Failed to cancel booking request", { cause: error });
+	});
+};
+//#endregion
+exports.allocateVehicle = allocateVehicle;
+exports.cancelBookingRequest = cancelBookingRequest;
+exports.deallocateVehicle = deallocateVehicle;
+exports.getAvailableVehicles = getAvailableVehicles;
+exports.getBookingRequestById = getBookingRequestById;
+exports.getBookingRequestByTrip = getBookingRequestByTrip;
+exports.getBookingRequests = getBookingRequests;
+exports.getBookingRequestsByUserId = getBookingRequestsByUserId;
+exports.getSATBookingRequests = getSATBookingRequests;
+exports.getScheduleBookingRequests = getScheduleBookingRequests;
+exports.getStationById = getStationById;
+exports.getStations = getStations;
+exports.getSubscriptionBookingRequestById = getSubscriptionBookingRequestById;
+exports.getSubscriptionBookingRequests = getSubscriptionBookingRequests;
+exports.releaseBRPayment = releaseBRPayment;
+exports.triggerBRPayment = triggerBRPayment;
+exports.updateScheduleBooking = updateScheduleBooking;