@driveflux/api-functions 1.0.44 → 1.0.45

package/dist/reservation/display-vehicle.js

@@ -1,73 +1,75 @@
 import { config } from '@driveflux/config/backend';
-import { prisma, } from '@driveflux/db';
+import { prisma } from '@driveflux/db';
 import { generateId } from '@driveflux/db/id';
 import { createPricingController } from '@driveflux/db/models/vehicle';
-import { getFluxExcessMileage, getFluxPiceMatrix, getHostExcessMileage, getHostsMatrix, getRecommendedMotorcycleDeposit, getStartFeeMatrix, } from '../vehicle/vehicle-pricing/index.js';
-export const fetchDisplayVehicle = async (displayVehicle) => {
-    return typeof displayVehicle === 'string'
-        ? await prisma.displayVehicle.findFirst({ where: { id: displayVehicle } })
-        : displayVehicle;
+import { getFluxExcessMileage, getFluxPiceMatrix, getHostExcessMileage, getHostsMatrix, getRecommendedMotorcycleDeposit, getStartFeeMatrix } from '../vehicle/vehicle-pricing/index.js';
+export const fetchDisplayVehicle = async (displayVehicle)=>{
+    return typeof displayVehicle === 'string' ? await prisma.displayVehicle.findFirst({
+        where: {
+            id: displayVehicle
+        }
+    }) : displayVehicle;
 };
-export const createVehicleFromDisplayVehicle = async (displayVehicle, selectedColor) => {
+export const createVehicleFromDisplayVehicle = async (displayVehicle, selectedColor)=>{
     const dv = await fetchDisplayVehicle(displayVehicle);
-    if (!dv || typeof dv !== 'object')
-        return;
-    if (!dv.details)
-        return;
-    const mainImage = dv.images.main.find((m) => m.variant === selectedColor)?.url;
+    if (!dv || typeof dv !== 'object') return;
+    if (!dv.details) return;
+    const mainImage = dv.images.main.find((m)=>m.variant === selectedColor)?.url;
     const vehicleData = {
         id: generateId('Vehicle'),
         ...transformBasicVehicleData(dv),
         images: [
-            ...(mainImage ? [transfromSingleImage(mainImage)] : []),
-            ...transformImages(dv.images),
+            ...mainImage ? [
+                transfromSingleImage(mainImage)
+            ] : [],
+            ...transformImages(dv.images)
         ],
         ...transformBasePrices(dv.pricing),
         pricing: transformPriceMatrix(dv.type, dv.pricing),
         details: transformDetails(dv.details, selectedColor),
         host: {
             connect: {
-                id: dv.defaultHostId,
-            },
+                id: dv.defaultHostId
+            }
         },
         displayVehicle: {
             connect: {
-                id: dv.id,
-            },
-        },
+                id: dv.id
+            }
+        }
     };
     return await prisma.vehicle.create({
         data: vehicleData,
         include: {
-            host: true,
-        },
+            host: true
+        }
     });
 };
-export const transfromVehicleDisplayToVehicle = async (displayVehicle, selectedColor) => {
+export const transfromVehicleDisplayToVehicle = async (displayVehicle, selectedColor)=>{
     const dv = await fetchDisplayVehicle(displayVehicle);
-    if (!dv || typeof dv !== 'object')
-        return;
-    if (!dv.details)
-        return;
-    const mainImage = dv.images.main.find((m) => m.variant === selectedColor)?.url;
+    if (!dv || typeof dv !== 'object') return;
+    if (!dv.details) return;
+    const mainImage = dv.images.main.find((m)=>m.variant === selectedColor)?.url;
     return {
         id: dv.id,
         ...transformBasicVehicleData(dv),
         images: [
-            ...(mainImage ? [transfromSingleImage(mainImage)] : []),
-            ...transformImages(dv.images),
+            ...mainImage ? [
+                transfromSingleImage(mainImage)
+            ] : [],
+            ...transformImages(dv.images)
         ],
         ...transformBasePrices(dv.pricing),
         pricing: transformPriceMatrix(dv.type, dv.pricing),
         details: transformDetails(dv.details, selectedColor),
         host: {
             address: {
-                state: 'Kuala Lumpur',
-            },
-        },
+                state: 'Kuala Lumpur'
+            }
+        }
     };
 };
-export const transformBasicVehicleData = (dv) => {
+export const transformBasicVehicleData = (dv)=>{
     return {
         registrationNumber: null,
         featured: false,
@@ -85,17 +87,17 @@ export const transformBasicVehicleData = (dv) => {
         type: dv.type,
         niceName: `${dv.make} ${dv.vehicleModel} ${dv.variant} ${dv.year}`,
         niceNameShort: `${dv.make} ${dv.vehicleModel}`,
-        appliedCoupon: dv.appliedCoupon,
+        appliedCoupon: dv.appliedCoupon
     };
 };
-export const transformImages = (images) => {
+export const transformImages = (images)=>{
     return [
         transfromSingleImage(images.exterior[0].url, 'exterior'),
         transfromSingleImage(images.interior[0].url, 'interior'),
-        ...images.gallery.map((i) => transfromSingleImage(i.url)),
+        ...images.gallery.map((i)=>transfromSingleImage(i.url))
     ];
 };
-const transfromSingleImage = (imageUrl, inspectionType) => {
+const transfromSingleImage = (imageUrl, inspectionType)=>{
     return {
         default: imageUrl,
         blurBase64: null,
@@ -106,20 +108,20 @@ const transfromSingleImage = (imageUrl, inspectionType) => {
         description: null,
         inspection: !!inspectionType,
         inspectionType: inspectionType || null,
-        notActualPhoto: true,
+        notActualPhoto: true
     };
 };
-const transformBasePrices = (pricing) => {
+const transformBasePrices = (pricing)=>{
     return {
         basePrice: pricing.matrix.plan36.lite,
         basePricePlan1: pricing.matrix.plan1.lite,
         basePricePlan12: pricing.matrix.plan12.lite,
         basePricePlan24: pricing.matrix.plan24.lite,
         basePricePlan36: pricing.matrix.plan36.lite,
-        basePricePlan60: pricing.matrix.plan60.lite,
+        basePricePlan60: pricing.matrix.plan60.lite
     };
 };
-const transformPriceMatrix = (vehicleType, pricing) => {
+const transformPriceMatrix = (vehicleType, pricing)=>{
     const baseline = pricing?.matrix.plan36.lite;
     const ultraTier = 'tier1';
     const fluxPriceCoefficient = 25;
@@ -132,16 +134,14 @@ const transformPriceMatrix = (vehicleType, pricing) => {
     const { availablePlans, availableMileagePackages } = getNonZeroKeys(priceMatrix);
     const pricingController = createPricingController({
         coefficient: fluxPriceCoefficient,
-        vehicleType,
+        vehicleType
     });
     const startFeeMatrix = excludeServiceFeesFrom(getStartFeeMatrix(pricingController, baseline, flatPricing));
     const hostMatrix = excludeServiceFeesFrom(getHostsMatrix(pricingController, baseline, ultraTier, flatPricing));
     const hostExcessMileage = getHostExcessMileage(pricingController, baseline);
     const fluxPriceMatrix = excludeServiceFeesFrom(getFluxPiceMatrix(pricingController, vehicleType, baseline, hostMatrix, ultraTier, flatPricing));
     const fluxExcessMileage = getFluxExcessMileage(pricingController, baseline);
-    const recommendedDeposit = pricing.refundableDeposit || vehicleType === 'motorcycle'
-        ? getRecommendedMotorcycleDeposit(baseline)
-        : null;
+    const recommendedDeposit = pricing.refundableDeposit || vehicleType === 'motorcycle' ? getRecommendedMotorcycleDeposit(baseline) : null;
     return {
         tmv,
         gfv,
@@ -160,31 +160,31 @@ const transformPriceMatrix = (vehicleType, pricing) => {
             excessMileage: fluxExcessMileage,
             originalExcessMileage: fluxExcessMileage,
             matrixComments: null,
-            add: null,
+            add: null
         },
         hostTake: {
             matrix: hostMatrix,
             originalMatrix: hostMatrix,
             excessMileage: hostExcessMileage,
             originalExcessMileage: hostExcessMileage,
-            matrixComments: null,
+            matrixComments: null
         },
         startFee: {
             matrix: startFeeMatrix,
             originalMatrix: startFeeMatrix,
-            matrixComments: null,
-        },
+            matrixComments: null
+        }
     };
 };
-const getNonZeroKeys = (matrix) => {
+const getNonZeroKeys = (matrix)=>{
     const planKeys = new Set();
     const mileageKeys = new Set();
-    for (const [plan, mileageMap] of Object.entries(matrix)) {
+    for (const [plan, mileageMap] of Object.entries(matrix)){
         const entries = Object.entries(mileageMap ?? {});
-        const hasNonZero = entries.some(([_, value]) => (value ?? 0) > 0);
+        const hasNonZero = entries.some(([_, value])=>(value ?? 0) > 0);
         if (hasNonZero) {
             planKeys.add(plan);
-            for (const [mileage, value] of entries) {
+            for (const [mileage, value] of entries){
                 if ((value ?? 0) > 0) {
                     mileageKeys.add(mileage);
                 }
@@ -193,20 +193,20 @@ const getNonZeroKeys = (matrix) => {
     }
     return {
         availablePlans: Array.from(planKeys),
-        availableMileagePackages: Array.from(mileageKeys),
+        availableMileagePackages: Array.from(mileageKeys)
     };
 };
-const _getInspection = () => {
+const _getInspection = ()=>{
     return {
         exterior: 5,
         interior: 5,
         engine: 5,
         frame: 5,
         total: 5,
-        comment: 'COMMENT HERE',
+        comment: 'COMMENT HERE'
     };
 };
-const transformDetails = (details, selectColor) => {
+const transformDetails = (details, selectColor)=>{
     const color = selectColor || details.colors[0].name || '';
     return {
         numberOfSeats: details.numberOfSeats,
@@ -214,31 +214,25 @@ const transformDetails = (details, selectColor) => {
         bodyType: details.bodyType,
         transmission: details.transmission,
         engineType: details.fuelType,
-        engineCapacity: details.fuelType === 'electric'
-            ? details.batteryCapacity
-            : details.engineCapacity,
+        engineCapacity: details.fuelType === 'electric' ? details.batteryCapacity : details.engineCapacity,
         drivetrain: details.drivetrain,
         accelerationTo100km: details.accelerationTo100km,
         fuelConsumptionLitersPer100Km: details.fuelConsumptionLitersPer100Km,
         color,
         features: details.features,
-        condition: 'new',
+        condition: 'new'
     };
 };
-const excludeServiceFeesFrom = (originalMatrix) => {
+const excludeServiceFeesFrom = (originalMatrix)=>{
     const matrix = {};
-    for (const [planKey, planValue] of Object.entries(originalMatrix)) {
-        if (!planValue)
-            continue;
-        if (!matrix[planKey])
-            matrix[planKey] = {};
-        for (const [mileageKey, price] of Object.entries(planValue)) {
+    for (const [planKey, planValue] of Object.entries(originalMatrix)){
+        if (!planValue) continue;
+        if (!matrix[planKey]) matrix[planKey] = {};
+        for (const [mileageKey, price] of Object.entries(planValue)){
             if (typeof price === 'number') {
-                matrix[planKey][mileageKey] =
-                    price / (1 + config.serviceRate);
+                matrix[planKey][mileageKey] = price / (1 + config.serviceRate);
             }
         }
     }
     return matrix;
 };
-//# sourceMappingURL=display-vehicle.js.map

package/dist/reservation/ensure-user-billing-address.js

@@ -3,29 +3,27 @@ import { makeProblem, PROBLEM_INTERNAL } from '@driveflux/problem';
 import { Err, Ok } from '@driveflux/result';
 import { createScopedLogger } from '../create-logger.js';
 const log = createScopedLogger('reservation:ensure-user-billing-address');
-export const ensureUserBillingAddress = async (userOrBusiness, deliveryAddresses) => {
+export const ensureUserBillingAddress = async (userOrBusiness, deliveryAddresses)=>{
     if (userOrBusiness.addresses?.billing) {
         return new Ok(userOrBusiness);
     }
     try {
         const fullQuery = {
-            where: { id: userOrBusiness.id },
+            where: {
+                id: userOrBusiness.id
+            },
             data: {
                 addresses: {
                     home: deliveryAddresses.home,
-                    billing: deliveryAddresses.billing,
-                },
-            },
+                    billing: deliveryAddresses.billing
+                }
+            }
         };
         // Use the delivery addresses
-        const updatedUserOrBusiness = userOrBusiness.object === 'user'
-            ? await prisma.user.update(fullQuery)
-            : await prisma.business.update(fullQuery);
+        const updatedUserOrBusiness = userOrBusiness.object === 'user' ? await prisma.user.update(fullQuery) : await prisma.business.update(fullQuery);
         return new Ok(updatedUserOrBusiness);
-    }
-    catch (error) {
+    } catch (error) {
         log.error(error, 'Failed to ensure user billing address');
         return new Err(makeProblem(PROBLEM_INTERNAL, 'Failed to ensure user billing address'));
     }
 };
-//# sourceMappingURL=ensure-user-billing-address.js.map

package/dist/reservation/fetch-or-create.js

@@ -1,11 +1,11 @@
-import { prisma, } from '@driveflux/db';
+import { prisma } from '@driveflux/db';
 import { generateId } from '@driveflux/db/id';
 import { reportError } from '@driveflux/reporter';
 import { Ok } from '@driveflux/result';
 import { slackLater } from '../slack.js';
-import { createReservationInvoice, updateReservationInvoiceIfNeeded, } from './invoice.js';
-export const fetchOrCreateReservation = async ({ vehicle, payer, body, }) => {
-    const { subscribingUser, plan, mileagePackage, couponCode, referralCode, asBusiness, source, deliveryAddresses, deliveryDate, analytics, paymentIntentId, freeReservation, freeReservationReason, } = body;
+import { createReservationInvoice, updateReservationInvoiceIfNeeded } from './invoice.js';
+export const fetchOrCreateReservation = async ({ vehicle, payer, body })=>{
+    const { subscribingUser, plan, mileagePackage, couponCode, referralCode, asBusiness, source, deliveryAddresses, deliveryDate, analytics, paymentIntentId, freeReservation, freeReservationReason } = body;
     try {
         const previousReservation = await prisma.subscriptionReservation.findFirst({
             where: {
@@ -19,14 +19,14 @@ export const fetchOrCreateReservation = async ({ vehicle, payer, body, }) => {
                 source,
                 // If the subscription ID was populated, this means that this reservation was consumed into a subsription,
                 // so we shouldn't re-use it
-                subscription: null,
+                subscription: null
             },
             orderBy: {
-                updatedAt: 'desc',
+                updatedAt: 'desc'
             },
             include: {
-                invoice: true,
-            },
+                invoice: true
+            }
         });
         if (previousReservation) {
             if (previousReservation.invoice.voided) {
@@ -39,7 +39,7 @@ export const fetchOrCreateReservation = async ({ vehicle, payer, body, }) => {
                 'partiallyPaid',
                 'partiallyRefunded',
                 'refunded',
-                'pendingRefund',
+                'pendingRefund'
             ];
             if (wrongStatuses.includes(previousReservation.invoice.status)) {
                 const updatedReservation = await recreateReservationInvoiceAndUpdateReservation(previousReservation, body, vehicle, payer);
@@ -52,16 +52,16 @@ export const fetchOrCreateReservation = async ({ vehicle, payer, body, }) => {
                         text: {
                             type: 'plain_text',
                             text: '‼️ Reservation invoice in wrong status',
-                            emoji: true,
-                        },
+                            emoji: true
+                        }
                     },
                     {
                         type: 'section',
                         text: {
                             type: 'plain_text',
-                            text: `The reservation invoice ${previousReservation.invoice.id} was in a wrong status (${previousReservation.invoice.status}), it was discarded and a new invoice (${updatedReservation.val.id}) was created, however, investigate the issue.`,
-                        },
-                    },
+                            text: `The reservation invoice ${previousReservation.invoice.id} was in a wrong status (${previousReservation.invoice.status}), it was discarded and a new invoice (${updatedReservation.val.id}) was created, however, investigate the issue.`
+                        }
+                    }
                 ]);
                 return updatedReservation;
             }
@@ -73,8 +73,7 @@ export const fetchOrCreateReservation = async ({ vehicle, payer, body, }) => {
             // Otherwise, we need to create a new reservation
             return new Ok(previousReservation);
         }
-    }
-    catch (error) {
+    } catch (error) {
         // We couldn't fetch the reservation, so we create a new one and just log this
         await reportError(error);
     }
@@ -93,7 +92,7 @@ export const fetchOrCreateReservation = async ({ vehicle, payer, body, }) => {
         analytics,
         vehicle,
         payer,
-        subscribingUser,
+        subscribingUser
     });
     if (invoiceResult.err) {
         return invoiceResult;
@@ -112,70 +111,66 @@ export const fetchOrCreateReservation = async ({ vehicle, payer, body, }) => {
         deliveryAddresses,
         deliveryDate,
         asBusiness,
-        source,
+        source
     });
     return new Ok(reservation);
 };
-const createReservation = async ({ reservationId, invoiceId, subscribingUserId, vehicleId, businessId, plan, mileagePackage, couponCode, referralCode, analytics, deliveryAddresses, deliveryDate, asBusiness, source, }) => {
+const createReservation = async ({ reservationId, invoiceId, subscribingUserId, vehicleId, businessId, plan, mileagePackage, couponCode, referralCode, analytics, deliveryAddresses, deliveryDate, asBusiness, source })=>{
     return await prisma.subscriptionReservation.create({
         data: {
             id: reservationId,
             invoice: {
                 connect: {
-                    id: invoiceId,
-                },
+                    id: invoiceId
+                }
             },
             user: {
                 connect: {
-                    id: subscribingUserId,
-                },
+                    id: subscribingUserId
+                }
             },
             vehicle: {
                 connect: {
-                    id: vehicleId,
-                },
+                    id: vehicleId
+                }
             },
-            ...(businessId
-                ? {
-                    business: {
-                        connect: {
-                            id: businessId,
-                        },
-                    },
+            ...businessId ? {
+                business: {
+                    connect: {
+                        id: businessId
+                    }
                 }
-                : undefined),
+            } : undefined,
             plan,
             mileagePackage,
             couponCode: couponCode,
             deliveryAddresses: deliveryAddresses,
             deliveryDate: deliveryDate,
-            ...(referralCode
-                ? {
-                    referral: {
-                        connect: {
-                            id: referralCode,
-                        },
-                    },
+            ...referralCode ? {
+                referral: {
+                    connect: {
+                        id: referralCode
+                    }
                 }
-                : undefined),
+            } : undefined,
             asBusiness: !!asBusiness,
             source,
             metadata: {
-                analytics,
-            },
+                analytics
+            }
         },
         include: {
-            invoice: true,
-        },
+            invoice: true
+        }
     });
 };
-const recreateReservationInvoiceAndUpdateReservation = async (previousReservation, body, vehicle, payer) => {
+const recreateReservationInvoiceAndUpdateReservation = async (previousReservation, body, vehicle, payer)=>{
     const invoiceResult = await createReservationInvoice({
         ...body,
         invoiceId: generateId('Invoice'),
         reservationId: previousReservation.id,
         vehicle,
-        payer,
+        payer
     });
     if (!invoiceResult.ok) {
         return invoiceResult;
@@ -183,19 +178,18 @@ const recreateReservationInvoiceAndUpdateReservation = async (previousReservatio
     const invoice = invoiceResult.val;
     const updatedReservation = await prisma.subscriptionReservation.update({
         where: {
-            id: previousReservation.id,
+            id: previousReservation.id
         },
         data: {
             invoice: {
                 connect: {
-                    id: invoice.id,
-                },
-            },
+                    id: invoice.id
+                }
+            }
         },
         include: {
-            invoice: true,
-        },
+            invoice: true
+        }
     });
     return new Ok(updatedReservation);
 };
-//# sourceMappingURL=fetch-or-create.js.map

package/dist/reservation/payer.js

@@ -1,7 +1,7 @@
 import { prisma } from '@driveflux/db';
-import { makeProblem, PROBLEM_CONDITION_FAILED, PROBLEM_NOT_FOUND, } from '@driveflux/problem';
+import { makeProblem, PROBLEM_CONDITION_FAILED, PROBLEM_NOT_FOUND } from '@driveflux/problem';
 import { Err, Ok } from '@driveflux/result';
-export const getPayer = async ({ subscribingUser, asBusiness, }) => {
+export const getPayer = async ({ subscribingUser, asBusiness })=>{
     let business = null;
     let payer = subscribingUser;
     if (asBusiness) {
@@ -11,8 +11,8 @@ export const getPayer = async ({ subscribingUser, asBusiness, }) => {
         // load business
         business = await prisma.business.findUnique({
             where: {
-                id: subscribingUser.businessId,
-            },
+                id: subscribingUser.businessId
+            }
         });
         if (!business) {
             return new Err(makeProblem(PROBLEM_NOT_FOUND, `The business ${subscribingUser.businessId} was not found.`));
@@ -26,7 +26,7 @@ export const getPayer = async ({ subscribingUser, asBusiness, }) => {
     }
     return new Ok(payer);
 };
-const checkPayerObjectSanity = (subscriber) => {
+const checkPayerObjectSanity = (subscriber)=>{
     if (!subscriber.email) {
         return new Err(makeProblem(PROBLEM_CONDITION_FAILED, `Subscriber ${subscriber.id} has no email. Please add a verified email first.`));
     }
@@ -35,4 +35,3 @@ const checkPayerObjectSanity = (subscriber) => {
     }
     return new Ok(true);
 };
-//# sourceMappingURL=payer.js.map

package/dist/reservation/reserve.js

@@ -6,14 +6,14 @@ import { fetchOrCreateReservation } from './fetch-or-create.js';
 import { getPayer } from './payer.js';
 import { ensurePaymentIntentIdIsSynced } from './payment-intent-sync.js';
 import { getVehicle } from './vehicle.js';
-const processBody = (body) => {
+const processBody = (body)=>{
     // Switch mileage package
     if (body.plan === 'plan1' || body.plan === 'planWeekly') {
         body.mileagePackage = 'unlimited';
     }
     return body;
 };
-export const reserveVehicle = async (vehicleId, unprocessed) => {
+export const reserveVehicle = async (vehicleId, unprocessed)=>{
     const body = processBody(unprocessed);
     // Agree to terms if not done yet
     await handleAgreeToTerms(body);
@@ -41,7 +41,7 @@ export const reserveVehicle = async (vehicleId, unprocessed) => {
     const reservationResult = await fetchOrCreateReservation({
         vehicle,
         payer,
-        body,
+        body
     });
     if (reservationResult.err) {
         return reservationResult;
@@ -57,4 +57,3 @@ export const reserveVehicle = async (vehicleId, unprocessed) => {
     }
     return new Ok(reservation);
 };
-//# sourceMappingURL=reserve.js.map

package/dist/reservation/types.js

@@ -1,2 +1 @@
-export {};
-//# sourceMappingURL=types.js.map
+export { };

package/dist/reservation/vehicle.js

@@ -4,21 +4,19 @@ import { makeProblem, PROBLEM_NOT_FOUND } from '@driveflux/problem';
 import { Err, Ok } from '@driveflux/result';
 import { checkIfVehicleIsAvailableForReservation } from './checks.js';
 import { createVehicleFromDisplayVehicle } from './display-vehicle.js';
-export const getVehicle = async (id, { selectedColor, plan, requestUser, }, requesterAbility) => {
-    const vehicle = id.startsWith('DV_')
-        ? await createVehicleFromDisplayVehicle(id, selectedColor || undefined)
-        : await prisma.vehicle.findUnique({
-            where: {
-                id,
-            },
-            include: {
-                host: {
-                    select: {
-                        id: true,
-                    },
-                },
-            },
-        });
+export const getVehicle = async (id, { selectedColor, plan, requestUser }, requesterAbility)=>{
+    const vehicle = id.startsWith('DV_') ? await createVehicleFromDisplayVehicle(id, selectedColor || undefined) : await prisma.vehicle.findUnique({
+        where: {
+            id
+        },
+        include: {
+            host: {
+                select: {
+                    id: true
+                }
+            }
+        }
+    });
     if (!vehicle) {
         return new Err(makeProblem(PROBLEM_NOT_FOUND, 'Vehicle not found'));
     }
@@ -29,4 +27,3 @@ export const getVehicle = async (id, { selectedColor, plan, requestUser, }, requ
     }
     return new Ok(vehicle);
 };
-//# sourceMappingURL=vehicle.js.map