@driveflux/api-functions 1.0.72 → 1.0.74

package/dist/reservation/invoice.js

@@ -1,31 +1,28 @@
 import { config } from '@driveflux/config/backend';
 import { loadCoupon, PROBLEM_APPLICABLE_NOT_FOUND } from '@driveflux/coupon';
-import { prisma, } from '@driveflux/db';
+import { prisma } from '@driveflux/db';
 import { generateId } from '@driveflux/db/id';
 import { EMPTY_BILLING_ADDRESS } from '@driveflux/db/models/other';
-import { INVOICE_LINE_CYCLE, INVOICE_LINE_DEPOSIT, INVOICE_LINE_OTHER, INVOICE_LINE_RESERVATION_FEE, PURPOSE_FULL_BOOKING, PURPOSE_RESERVATION, } from '@driveflux/db/models/subscription';
+import { PURPOSE_RESERVATION } from '@driveflux/db/models/subscription';
 import { userName } from '@driveflux/db/models/user';
 import { vehicleName } from '@driveflux/db/models/vehicle';
 import { biller, coupons } from '@driveflux/engine';
 import { wrapInResult } from '@driveflux/engine/utils';
-import { makeProblem, PROBLEM_EXTERNAL } from '@driveflux/problem';
-import { Err, Ok } from '@driveflux/result';
+import { Ok } from '@driveflux/result';
 import { format } from '@driveflux/time';
-import currency from 'currency.js';
 import { isAfter } from 'date-fns/isAfter';
 import { subMinutes } from 'date-fns/subMinutes';
 import { createScopedLogger } from '../create-logger.js';
 const log = createScopedLogger('reservation:invoice');
-export const updateReservationInvoiceIfNeeded = async (oldReservationInvoice, newParams) => {
+export const updateReservationInvoiceIfNeeded = async (oldReservationInvoice, newParams)=>{
     const couponIsDifferent = oldReservationInvoice.couponCode !== newParams.couponCode;
-    if (!couponIsDifferent &&
-        oldReservationInvoice.stripePaymentIntentId === newParams.paymentIntentId) {
+    if (!couponIsDifferent && oldReservationInvoice.stripePaymentIntentId === newParams.paymentIntentId) {
         return new Ok(oldReservationInvoice);
     }
     // If the coupon or payment intent are differnt we should update the invoice
     let update = {
         stripePaymentIntentId: newParams.paymentIntentId,
-        couponCode: newParams.couponCode,
+        couponCode: newParams.couponCode
     };
     // If the coupon is different, we need to apply the coupon to the invoice
     if (couponIsDifferent) {
@@ -33,63 +30,56 @@ export const updateReservationInvoiceIfNeeded = async (oldReservationInvoice, ne
             const result = await coupons.applyCouponToUnsavedInvoice(newParams.couponCode, oldReservationInvoice);
             if (result.ok) {
                 const { discounts, ...rest } = result.val;
-                const toDisconnect = discounts
-                    ? oldReservationInvoice.discountIds?.filter((id) => !discounts.connect?.some((d) => d.id === id))
-                    : undefined;
-                const disconnectClauses = toDisconnect?.length
-                    ? {
-                        disconnect: toDisconnect.map((id) => ({ id })),
-                    }
-                    : undefined;
+                const toDisconnect = discounts ? oldReservationInvoice.discountIds?.filter((id)=>!discounts.connect?.some((d)=>d.id === id)) : undefined;
+                const disconnectClauses = toDisconnect?.length ? {
+                    disconnect: toDisconnect.map((id)=>({
+                            id
+                        }))
+                } : undefined;
                 update = {
                     ...update,
                     ...rest,
-                    ...(discounts || disconnectClauses
-                        ? {
-                            discounts: {
-                                ...(discounts || {}),
-                                ...(disconnectClauses || {}),
-                            },
+                    ...discounts || disconnectClauses ? {
+                        discounts: {
+                            ...discounts || {},
+                            ...disconnectClauses || {}
                         }
-                        : {}),
+                    } : {},
                     metadata: {
                         ...update.metadata,
-                        couponCode: newParams.couponCode,
+                        couponCode: newParams.couponCode
                     },
                     providerMetadata: {
                         ...update.providerMetadata,
-                        couponCode: newParams.couponCode,
-                    },
+                        couponCode: newParams.couponCode
+                    }
                 };
             }
             if (result.err && result.val.code !== PROBLEM_APPLICABLE_NOT_FOUND) {
                 return result;
             }
-        }
-        else if (oldReservationInvoice.discountIds.length) {
+        } else if (oldReservationInvoice.discountIds.length) {
             // No discounts, so we disconnect all of them
             update = {
                 discounts: {
-                    disconnect: oldReservationInvoice.discountIds.map((id) => ({
-                        id,
-                    })),
-                },
+                    disconnect: oldReservationInvoice.discountIds.map((id)=>({
+                            id
+                        }))
+                }
             };
         }
     }
     let updated = await wrapInResult(biller.updateInvoice(oldReservationInvoice.id, update));
     // If the invoice was locked due to pending status and we're more than 1 minute old, we unlock it
     if (updated.err && updated.val.code === 'invoice_pending') {
-        if ((oldReservationInvoice.lockedAt &&
-            isAfter(oldReservationInvoice.lockedAt, subMinutes(new Date(), 1))) ||
-            !oldReservationInvoice.lockedAt) {
+        if (oldReservationInvoice.lockedAt && isAfter(oldReservationInvoice.lockedAt, subMinutes(new Date(), 1)) || !oldReservationInvoice.lockedAt) {
             updated = await wrapInResult(biller.updateInvoice(oldReservationInvoice.id, {
                 ...update,
                 locked: false,
                 lockedAt: null,
                 lockReason: null,
                 unlockAt: null,
-                status: 'draft',
+                status: 'draft'
             }));
         }
     }
@@ -98,8 +88,8 @@ export const updateReservationInvoiceIfNeeded = async (oldReservationInvoice, ne
     }
     return new Ok(updated.val);
 };
-export const createReservationInvoice = async ({ invoiceId, couponCode, plan, mileagePackage, referralCode, reservationId, paymentIntentId, freeReservation, freeReservationReason, analytics, vehicle, payer, subscribingUser, fullBooking, }) => {
-    if (freeReservation && !fullBooking) {
+export const createReservationInvoice = async ({ invoiceId, couponCode, plan, mileagePackage, referralCode, reservationId, paymentIntentId, freeReservation, freeReservationReason, analytics, vehicle, payer, subscribingUser })=>{
+    if (freeReservation) {
         // It's a free reservation, so we don't need to add a coupon code
         return await wrapInResult(biller.createInvoice(getInvoiceCreateDetails({
             invoiceId,
@@ -107,24 +97,21 @@ export const createReservationInvoice = async ({ invoiceId, couponCode, plan, mi
             vehicle,
             plan,
             mileagePackage,
+            paymentIntentId,
             freeReservation,
             freeReservationReason,
             analytics,
-            reservationId,
+            reservationId
         })));
     }
     let finalCouponCode = couponCode;
     // If we don't have a reservation coupon ID, we apply the referral discount if any
-    const referral = referralCode &&
-        (await prisma.referral.findUnique({
-            where: {
-                id: referralCode,
-            },
-        }));
-    if (!finalCouponCode &&
-        referral &&
-        referral.discountToReceiverCouponId &&
-        referral.discountToReceiverCouponApplicationName === 'reservationFee') {
+    const referral = referralCode && await prisma.referral.findUnique({
+        where: {
+            id: referralCode
+        }
+    });
+    if (!finalCouponCode && referral && referral.discountToReceiverCouponId && referral.discountToReceiverCouponApplicationName === 'reservationFee') {
         const referralCoupon = await loadCoupon(referral.discountToReceiverCouponId);
         if (referralCoupon) {
             finalCouponCode = referralCoupon.code;
@@ -143,44 +130,20 @@ export const createReservationInvoice = async ({ invoiceId, couponCode, plan, mi
             freeReservation,
             freeReservationReason,
             analytics,
-            reservationId,
+            reservationId
         }),
-    };
-    if (fullBooking) {
-        invoiceCreateDetails.subscriptionPurpose = PURPOSE_FULL_BOOKING;
-        const vehiclePrice = vehicle.pricing?.fluxPrice.matrix[plan][mileagePackage];
-        if (!vehiclePrice) {
-            throw new Error('Vehicle price not found');
-        }
-        invoiceCreateDetails.lines = [
-            {
-                amount: vehiclePrice,
-                chargingFor: INVOICE_LINE_CYCLE,
-                description: `First payment for ${vehicleName(vehicle)}`,
-            },
-            {
-                amount: vehiclePrice * config.taxRate,
-                chargingFor: INVOICE_LINE_OTHER,
-                description: `Processing fee for ${vehicleName(vehicle)}`,
-            },
-            {
-                amount: vehiclePrice,
-                description: `Deposit for ${vehicleName(vehicle)}`,
-                chargingFor: INVOICE_LINE_DEPOSIT,
-            },
-        ];
-    }
-    else {
-        invoiceCreateDetails.lines = [
+        lines: [
             {
                 amount: reservationAmount,
                 description: `Reservation fee for ${vehicleName(vehicle)}`,
-                chargingFor: INVOICE_LINE_RESERVATION_FEE,
-            },
-        ];
-    }
+                chargingFor: 'reservationFee'
+            }
+        ]
+    };
     if (finalCouponCode) {
-        log.debug({ finalCouponCode }, 'Applying coupon code to invoice');
+        log.debug({
+            finalCouponCode
+        }, 'Applying coupon code to invoice');
         const withCoupon = await coupons.applyCouponToUnsavedInvoice(finalCouponCode, invoiceCreateDetails, 'reservationFee', {
             subscriptionPlans: plan,
             subscriptionMileagePackages: mileagePackage,
@@ -188,54 +151,41 @@ export const createReservationInvoice = async ({ invoiceId, couponCode, plan, mi
             vehicleMake: vehicle.make,
             userId: subscribingUser.id,
             businessId: payer.object === 'business' ? payer.id : undefined,
-            vehicleType: vehicle.type,
+            vehicleType: vehicle.type
         });
-        if (withCoupon.err &&
-            withCoupon.val.code !== PROBLEM_APPLICABLE_NOT_FOUND) {
+        if (withCoupon.err && withCoupon.val.code !== PROBLEM_APPLICABLE_NOT_FOUND) {
             return withCoupon;
         }
-        log.debug({ couponUpdates: withCoupon.val }, 'Coupon applied to invoice');
+        log.debug({
+            couponUpdates: withCoupon.val
+        }, 'Coupon applied to invoice');
         if (withCoupon.ok) {
             invoiceCreateDetails = {
                 ...withCoupon.val,
                 metadata: {
                     ...withCoupon.val.metadata,
-                    couponCode: finalCouponCode,
+                    couponCode: finalCouponCode
                 },
                 providerMetadata: {
                     ...withCoupon.val.providerMetadata,
-                    couponCode: finalCouponCode,
-                },
+                    couponCode: finalCouponCode
+                }
             };
         }
     }
-    // Validate the payment intent amount
-    if (paymentIntentId) {
-        const stripe = biller.getPaymentProvider('stripe').getStripe();
-        // Validate the payment intent
-        const paymentIntentResult = await wrapInResult(stripe.paymentIntents.retrieve(paymentIntentId));
-        if (paymentIntentResult.err) {
-            return new Err(makeProblem(PROBLEM_EXTERNAL, 'Payment intent not found'));
-        }
-        if (paymentIntentResult.val.amount !==
-            currency(biller.getCorrectedInvoiceData(invoiceCreateDetails).total)
-                .intValue) {
-            return new Err(makeProblem(PROBLEM_EXTERNAL, 'Payment intent amount does not match invoice amount'));
-        }
-    }
     const result = await wrapInResult(biller.createInvoice({
         ...invoiceCreateDetails,
         providerMetadata: {
             ...invoiceCreateDetails.providerMetadata,
-            invoiceId: invoiceCreateDetails.id,
-        },
+            invoiceId: invoiceCreateDetails.id
+        }
     }));
     if (result.err) {
         return result;
     }
     return new Ok(result.val);
 };
-const getInvoiceCreateDetails = ({ invoiceId, payer, date, reservationDiscountId, vehicle, plan, mileagePackage, couponCode, paymentIntentId, freeReservation, freeReservationReason, analytics, reservationId, }) => {
+const getInvoiceCreateDetails = ({ invoiceId, payer, date, reservationDiscountId, vehicle, plan, mileagePackage, couponCode, paymentIntentId, freeReservation, freeReservationReason, analytics, reservationId })=>{
     return {
         id: invoiceId || generateId('Invoice'),
         taxPercentage: 0,
@@ -251,15 +201,13 @@ const getInvoiceCreateDetails = ({ invoiceId, payer, date, reservationDiscountId
         description: 'Reservation fee for a FLUX subscription',
         footer: `Invoice for a FLUX subscription reservation. Due by ${format(date ?? new Date())}`,
         invoiceUrl: `${config.appUrl}/invoice-preview/${invoiceId}`,
-        ...(reservationDiscountId
-            ? {
-                discounts: {
-                    connect: {
-                        id: reservationDiscountId,
-                    },
-                },
+        ...reservationDiscountId ? {
+            discounts: {
+                connect: {
+                    id: reservationDiscountId
+                }
             }
-            : {}),
+        } : {},
         lines: [],
         subscriptionDetails: {
             vehicleId: vehicle.id,
@@ -268,7 +216,7 @@ const getInvoiceCreateDetails = ({ invoiceId, payer, date, reservationDiscountId
             variant: vehicle.variant,
             year: vehicle.year,
             plan: plan,
-            mileagePackage: mileagePackage,
+            mileagePackage: mileagePackage
         },
         // Legacy field:
         stripePaymentIntentId: paymentIntentId,
@@ -278,14 +226,18 @@ const getInvoiceCreateDetails = ({ invoiceId, payer, date, reservationDiscountId
             mileagePackage,
             vehicleId: vehicle.id,
             vehicleName: vehicleName(vehicle),
-            ...(reservationId ? { reservationId } : {}),
-            ...(couponCode ? { couponCode } : {}),
+            ...reservationId ? {
+                reservationId
+            } : {},
+            ...couponCode ? {
+                couponCode
+            } : {}
         },
         autoRetry: {
             enabled: false,
             interval: 0,
             maxAttempts: 0,
-            attempts: 0,
+            attempts: 0
         },
         metadata: {
             purpose: PURPOSE_RESERVATION,
@@ -294,11 +246,10 @@ const getInvoiceCreateDetails = ({ invoiceId, payer, date, reservationDiscountId
             plan,
             mileagePackage,
             couponCode,
-            ...(freeReservation && freeReservationReason
-                ? { freeReservationReason }
-                : {}),
-            analytics,
-        },
+            ...freeReservation && freeReservationReason ? {
+                freeReservationReason
+            } : {},
+            analytics
+        }
     };
 };
-//# sourceMappingURL=invoice.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/payment-intent-sync.js

@@ -3,20 +3,18 @@ import { makeProblem, PROBLEM_EXTERNAL } from '@driveflux/problem';
 import { Err, Ok } from '@driveflux/result';
 import { createScopedLogger } from '../create-logger.js';
 const log = createScopedLogger('reservation:payment-intent-sync');
-export const ensurePaymentIntentIdIsSynced = async (invoice, paymentIntentId) => {
+export const ensurePaymentIntentIdIsSynced = async (invoice, paymentIntentId)=>{
     const stripe = biller.getPaymentProvider('stripe').getStripe();
     try {
         await stripe.paymentIntents.update(paymentIntentId, {
             metadata: {
                 ...invoice.providerMetadata,
-                invoiceId: invoice.id,
-            },
+                invoiceId: invoice.id
+            }
         });
         return new Ok(true);
-    }
-    catch (error) {
+    } catch (error) {
         log.error(error, 'Error updating payment intent metadata');
         return new Err(makeProblem(PROBLEM_EXTERNAL, 'Error updating payment intent metadata'));
     }
 };
-//# sourceMappingURL=payment-intent-sync.js.map

package/dist/reservation/reserve.js

@@ -7,14 +7,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
     body.subscribingUser = await handleAgreeToTerms(body);
@@ -45,9 +45,8 @@ export const reserveVehicle = async (vehicleId, unprocessed) => {
     const reservationResult = await fetchOrCreateReservation({
         vehicle,
         payer,
-        body,
+        body
     });
-    console.log('reservationResult?', reservationResult);
     if (reservationResult.err) {
         return reservationResult;
     }
@@ -62,4 +61,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

package/dist/slack.js

@@ -10,12 +10,11 @@ const slackBlocks = global.__slackBlocks;
 /**
  *
  * @deprecated Use slackLater instead and commitSlack to commit
- */
-export const slack = async (message, channel = config.slack.defaultChannelId) => {
+ */ export const slack = async (message, channel = config.slack.defaultChannelId)=>{
     return await enhancedFetch('https://slack.com/api/chat.postMessage', {
         method: 'POST',
         headers: {
-            Authorization: `Bearer ${config.slack.token}`,
+            Authorization: `Bearer ${config.slack.token}`
         },
         body: JSON.stringify({
             channel,
@@ -24,23 +23,20 @@ export const slack = async (message, channel = config.slack.defaultChannelId) =>
                     type: 'section',
                     text: {
                         type: 'mrkdwn',
-                        text: message,
-                    },
-                },
-            ],
-        }),
+                        text: message
+                    }
+                }
+            ]
+        })
     });
 };
-export const getSlackBlocks = (channel) => channel ? slackBlocks.get(channel) : slackBlocks;
+export const getSlackBlocks = (channel)=>channel ? slackBlocks.get(channel) : slackBlocks;
 /**
  * Naive implementation, however, for now (uncrowded serverless env), this works
  * @param blocks
  * @param channel
- */
-export function slackLater(blocks, channel) {
-    const targetChannel = (config.appEnv === 'production'
-        ? channel
-        : config.slack.defaultChannelId) || config.slack.defaultChannelId;
+ */ export function slackLater(blocks, channel) {
+    const targetChannel = (config.appEnv === 'production' ? channel : config.slack.defaultChannelId) || config.slack.defaultChannelId;
     if (!targetChannel || !blocks) {
         return;
     }
@@ -50,15 +46,13 @@ export function slackLater(blocks, channel) {
             type: 'section',
             text: {
                 type: 'mrkdwn',
-                text: blocks,
-            },
+                text: blocks
+            }
         });
-    }
-    else if (!Array.isArray(blocks)) {
+    } else if (!Array.isArray(blocks)) {
         messages.add(blocks);
-    }
-    else {
-        for (const b of blocks) {
+    } else {
+        for (const b of blocks){
             messages.add(b);
         }
     }
@@ -69,22 +63,22 @@ export async function sendSlackMessages(channel, blocks) {
     return await enhancedFetch('https://slack.com/api/chat.postMessage', {
         method: 'POST',
         headers: {
-            Authorization: `Bearer ${config.slack.token}`,
+            Authorization: `Bearer ${config.slack.token}`
         },
         body: JSON.stringify({
             channel: targetChannel,
-            blocks: Array.from(blocks),
-        }),
+            blocks: Array.from(blocks)
+        })
     });
 }
-export const commitSlack = () => {
+export const commitSlack = ()=>{
     if (!slackBlocks.size) {
         return;
     }
     const channels = slackBlocks.keys();
     let i = 1;
     const baseUrl = config.appEnv === 'development' ? config.tunnelUrl : config.appUrl;
-    for (const channel of channels) {
+    for (const channel of channels){
         const blocks = slackBlocks.get(channel);
         if (!blocks?.size) {
             continue;
@@ -94,12 +88,13 @@ export const commitSlack = () => {
             name: TASK_COMMIT_SLACK_CHANNEL,
             metadata: {
                 channel,
-                blocks: [...blocks],
+                blocks: [
+                    ...blocks
+                ]
             },
             taskHandlerUrl: `${baseUrl || config.appUrl}/api/hooks/slack-pipeline`,
-            scheduledAt: addSeconds(new Date(), i++),
+            scheduledAt: addSeconds(new Date(), i++)
         });
     }
     slackBlocks.clear();
 };
-//# sourceMappingURL=slack.js.map