@driveflux/api-functions 0.0.7-next.18 → 0.0.7-next.2

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

@@ -1,202 +1,492 @@
-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, invoiceId } = body;
+function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
     try {
-        const previousReservation = await prisma.subscriptionReservation.findFirst({
-            where: {
-                userId: subscribingUser.id,
-                vehicleId: vehicle.id,
-                plan,
-                mileagePackage,
-                couponCode,
-                referralCode,
-                asBusiness: !!asBusiness,
-                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
-            },
-            orderBy: {
-                updatedAt: 'desc'
-            },
-            include: {
-                invoice: {
-                    select: {
-                        id: true,
-                        voided: true,
-                        stripePaymentIntentId: true,
-                        couponCode: true,
-                        payerId: true,
-                        discountIds: true,
-                        lines: true,
-                        status: true,
-                        lockedAt: true,
-                        unlockAt: true,
-                        locked: true
-                    }
-                }
+        var info = gen[key](arg);
+        var value = info.value;
+    } catch (error) {
+        reject(error);
+        return;
+    }
+    if (info.done) {
+        resolve(value);
+    } else {
+        Promise.resolve(value).then(_next, _throw);
+    }
+}
+function _async_to_generator(fn) {
+    return function() {
+        var self = this, args = arguments;
+        return new Promise(function(resolve, reject) {
+            var gen = fn.apply(self, args);
+            function _next(value) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value);
             }
-        });
-        if (previousReservation) {
-            if (previousReservation.invoice.voided || previousReservation.invoice.id !== invoiceId) {
-                return recreateReservationInvoiceAndUpdateReservation(previousReservation, body, vehicle, payer);
+            function _throw(err) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err);
             }
-            // If the invoice is paid or partially paid, this is a serious problem,
-            // we need to make a notification about this and recreate the invoice
-            const wrongStatuses = [
-                'paid',
-                'partiallyPaid',
-                'partiallyRefunded',
-                'refunded',
-                'pendingRefund'
+            _next(undefined);
+        });
+    };
+}
+function _define_property(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        obj[key] = value;
+    }
+    return obj;
+}
+function _object_spread(target) {
+    for(var i = 1; i < arguments.length; i++){
+        var source = arguments[i] != null ? arguments[i] : {};
+        var ownKeys = Object.keys(source);
+        if (typeof Object.getOwnPropertySymbols === "function") {
+            ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function(sym) {
+                return Object.getOwnPropertyDescriptor(source, sym).enumerable;
+            }));
+        }
+        ownKeys.forEach(function(key) {
+            _define_property(target, key, source[key]);
+        });
+    }
+    return target;
+}
+function ownKeys(object, enumerableOnly) {
+    var keys = Object.keys(object);
+    if (Object.getOwnPropertySymbols) {
+        var symbols = Object.getOwnPropertySymbols(object);
+        if (enumerableOnly) {
+            symbols = symbols.filter(function(sym) {
+                return Object.getOwnPropertyDescriptor(object, sym).enumerable;
+            });
+        }
+        keys.push.apply(keys, symbols);
+    }
+    return keys;
+}
+function _object_spread_props(target, source) {
+    source = source != null ? source : {};
+    if (Object.getOwnPropertyDescriptors) {
+        Object.defineProperties(target, Object.getOwnPropertyDescriptors(source));
+    } else {
+        ownKeys(Object(source)).forEach(function(key) {
+            Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
+        });
+    }
+    return target;
+}
+function _ts_generator(thisArg, body) {
+    var f, y, t, _ = {
+        label: 0,
+        sent: function() {
+            if (t[0] & 1) throw t[1];
+            return t[1];
+        },
+        trys: [],
+        ops: []
+    }, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
+    return g.next = verb(0), g["throw"] = verb(1), g["return"] = verb(2), typeof Symbol === "function" && (g[Symbol.iterator] = function() {
+        return this;
+    }), g;
+    function verb(n) {
+        return function(v) {
+            return step([
+                n,
+                v
+            ]);
+        };
+    }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while(g && (g = 0, op[0] && (_ = 0)), _)try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [
+                op[0] & 2,
+                t.value
             ];
-            if (wrongStatuses.includes(previousReservation.invoice.status)) {
-                const updatedReservation = await recreateReservationInvoiceAndUpdateReservation(previousReservation, body, vehicle, payer);
-                if (updatedReservation.err) {
-                    return updatedReservation;
-                }
-                slackLater([
-                    {
-                        type: 'header',
-                        text: {
-                            type: 'plain_text',
-                            text: '‼️ Reservation invoice in wrong status',
-                            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.`
-                        }
+            switch(op[0]){
+                case 0:
+                case 1:
+                    t = op;
+                    break;
+                case 4:
+                    _.label++;
+                    return {
+                        value: op[1],
+                        done: false
+                    };
+                case 5:
+                    _.label++;
+                    y = op[1];
+                    op = [
+                        0
+                    ];
+                    continue;
+                case 7:
+                    op = _.ops.pop();
+                    _.trys.pop();
+                    continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) {
+                        _ = 0;
+                        continue;
                     }
-                ]);
-                return updatedReservation;
-            }
-            // If the payment intent ID is different, we need to update it
-            const updated = await updateReservationInvoiceIfNeeded(previousReservation.invoice, body);
-            if (updated.err) {
-                return updated;
+                    if (op[0] === 3 && (!t || op[1] > t[0] && op[1] < t[3])) {
+                        _.label = op[1];
+                        break;
+                    }
+                    if (op[0] === 6 && _.label < t[1]) {
+                        _.label = t[1];
+                        t = op;
+                        break;
+                    }
+                    if (t && _.label < t[2]) {
+                        _.label = t[2];
+                        _.ops.push(op);
+                        break;
+                    }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop();
+                    continue;
             }
-            // Otherwise, we need to create a new reservation
-            return new Ok(previousReservation);
+            op = body.call(thisArg, _);
+        } catch (e) {
+            op = [
+                6,
+                e
+            ];
+            y = 0;
+        } finally{
+            f = t = 0;
         }
-    } catch (error) {
-        // We couldn't fetch the reservation, so we create a new one and just log this
-        await reportError(error);
-    }
-    const reservationId = generateId('SubscriptionReservation');
-    // Create the reservation invoice
-    const invoiceResult = await createReservationInvoice({
-        invoiceId,
-        couponCode,
-        plan,
-        mileagePackage,
-        referralCode,
-        reservationId,
-        paymentIntentId,
-        freeReservation,
-        freeReservationReason,
-        analytics,
-        vehicle,
-        payer,
-        subscribingUser
-    });
-    if (invoiceResult.err) {
-        return invoiceResult;
+        if (op[0] & 5) throw op[1];
+        return {
+            value: op[0] ? op[1] : void 0,
+            done: true
+        };
     }
-    const reservation = await createReservation({
-        reservationId,
-        invoiceId: invoiceResult.val.id,
-        subscribingUserId: subscribingUser.id,
-        vehicleId: vehicle.id,
-        businessId: payer.object === 'business' ? payer.id : undefined,
-        plan,
-        mileagePackage,
-        couponCode,
-        referralCode,
-        analytics,
-        deliveryAddresses,
-        deliveryDate,
-        asBusiness,
-        source
-    });
-    return new Ok(reservation);
-};
-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
-                }
-            },
-            user: {
-                connect: {
-                    id: subscribingUserId
-                }
-            },
-            vehicle: {
-                connect: {
-                    id: vehicleId
-                }
-            },
-            ...businessId ? {
-                business: {
-                    connect: {
-                        id: businessId
+}
+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';
+import { createReservationInvoice, updateReservationInvoiceIfNeeded } from './invoice';
+export var fetchOrCreateReservation = function(param) {
+    var vehicle = param.vehicle, payer = param.payer, body = param.body;
+    return _async_to_generator(function() {
+        var subscribingUser, plan, mileagePackage, couponCode, referralCode, asBusiness, source, deliveryAddresses, deliveryDate, analytics, paymentIntentId, freeReservation, freeReservationReason, previousReservation, wrongStatuses, updatedReservation, updated, error, reservationId, invoiceResult, reservation;
+        return _ts_generator(this, function(_state) {
+            switch(_state.label){
+                case 0:
+                    subscribingUser = body.subscribingUser, plan = body.plan, mileagePackage = body.mileagePackage, couponCode = body.couponCode, referralCode = body.referralCode, asBusiness = body.asBusiness, source = body.source, deliveryAddresses = body.deliveryAddresses, deliveryDate = body.deliveryDate, analytics = body.analytics, paymentIntentId = body.paymentIntentId, freeReservation = body.freeReservation, freeReservationReason = body.freeReservationReason;
+                    _state.label = 1;
+                case 1:
+                    _state.trys.push([
+                        1,
+                        7,
+                        ,
+                        9
+                    ]);
+                    return [
+                        4,
+                        prisma.subscriptionReservation.findFirst({
+                            where: {
+                                userId: subscribingUser.id,
+                                vehicleId: vehicle.id,
+                                plan: plan,
+                                mileagePackage: mileagePackage,
+                                couponCode: couponCode,
+                                referralCode: referralCode,
+                                asBusiness: !!asBusiness,
+                                source: 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
+                            },
+                            orderBy: {
+                                updatedAt: 'desc'
+                            },
+                            include: {
+                                invoice: {
+                                    select: {
+                                        id: true,
+                                        voided: true,
+                                        stripePaymentIntentId: true,
+                                        couponCode: true,
+                                        payerId: true,
+                                        discountIds: true,
+                                        lines: true,
+                                        status: true,
+                                        lockedAt: true,
+                                        unlockAt: true,
+                                        locked: true
+                                    }
+                                }
+                            }
+                        })
+                    ];
+                case 2:
+                    previousReservation = _state.sent();
+                    if (!previousReservation) return [
+                        3,
+                        6
+                    ];
+                    if (previousReservation.invoice.voided) {
+                        return [
+                            2,
+                            recreateReservationInvoiceAndUpdateReservation(previousReservation, body, vehicle, payer)
+                        ];
+                    }
+                    // If the invoice is paid or partially paid, this is a serious problem,
+                    // we need to make a notification about this and recreate the invoice
+                    wrongStatuses = [
+                        'paid',
+                        'partiallyPaid',
+                        'partiallyRefunded',
+                        'refunded',
+                        'pendingRefund'
+                    ];
+                    if (!wrongStatuses.includes(previousReservation.invoice.status)) return [
+                        3,
+                        4
+                    ];
+                    return [
+                        4,
+                        recreateReservationInvoiceAndUpdateReservation(previousReservation, body, vehicle, payer)
+                    ];
+                case 3:
+                    updatedReservation = _state.sent();
+                    if (updatedReservation.err) {
+                        return [
+                            2,
+                            updatedReservation
+                        ];
                     }
-                }
-            } : undefined,
-            plan,
-            mileagePackage,
-            couponCode: couponCode,
-            deliveryAddresses: deliveryAddresses,
-            deliveryDate: deliveryDate,
-            ...referralCode ? {
-                referral: {
-                    connect: {
-                        id: referralCode
+                    slackLater([
+                        {
+                            type: 'header',
+                            text: {
+                                type: 'plain_text',
+                                text: '‼️ Reservation invoice in wrong status',
+                                emoji: true
+                            }
+                        },
+                        {
+                            type: 'section',
+                            text: {
+                                type: 'plain_text',
+                                text: "The reservation invoice ".concat(previousReservation.invoice.id, " was in a wrong status (").concat(previousReservation.invoice.status, "), it was discarded and a new invoice (").concat(updatedReservation.val.id, ") was created, however, investigate the issue.")
+                            }
+                        }
+                    ]);
+                    return [
+                        2,
+                        updatedReservation
+                    ];
+                case 4:
+                    return [
+                        4,
+                        updateReservationInvoiceIfNeeded(previousReservation.invoice, body)
+                    ];
+                case 5:
+                    updated = _state.sent();
+                    if (updated.err) {
+                        return [
+                            2,
+                            updated
+                        ];
+                    }
+                    // Otherwise, we need to create a new reservation
+                    return [
+                        2,
+                        new Ok(previousReservation)
+                    ];
+                case 6:
+                    return [
+                        3,
+                        9
+                    ];
+                case 7:
+                    error = _state.sent();
+                    // We couldn't fetch the reservation, so we create a new one and just log this
+                    return [
+                        4,
+                        reportError(error)
+                    ];
+                case 8:
+                    _state.sent();
+                    return [
+                        3,
+                        9
+                    ];
+                case 9:
+                    reservationId = generateId('SubscriptionReservation');
+                    return [
+                        4,
+                        createReservationInvoice({
+                            couponCode: couponCode,
+                            plan: plan,
+                            mileagePackage: mileagePackage,
+                            referralCode: referralCode,
+                            reservationId: reservationId,
+                            paymentIntentId: paymentIntentId,
+                            freeReservation: freeReservation,
+                            freeReservationReason: freeReservationReason,
+                            analytics: analytics,
+                            vehicle: vehicle,
+                            payer: payer,
+                            subscribingUser: subscribingUser
+                        })
+                    ];
+                case 10:
+                    invoiceResult = _state.sent();
+                    if (invoiceResult.err) {
+                        return [
+                            2,
+                            invoiceResult
+                        ];
                     }
-                }
-            } : undefined,
-            asBusiness: !!asBusiness,
-            source,
-            metadata: {
-                analytics
+                    return [
+                        4,
+                        createReservation({
+                            reservationId: reservationId,
+                            invoiceId: invoiceResult.val.id,
+                            subscribingUserId: subscribingUser.id,
+                            vehicleId: vehicle.id,
+                            businessId: payer.object === 'business' ? payer.id : undefined,
+                            plan: plan,
+                            mileagePackage: mileagePackage,
+                            couponCode: couponCode,
+                            referralCode: referralCode,
+                            analytics: analytics,
+                            deliveryAddresses: deliveryAddresses,
+                            deliveryDate: deliveryDate,
+                            asBusiness: asBusiness,
+                            source: source
+                        })
+                    ];
+                case 11:
+                    reservation = _state.sent();
+                    return [
+                        2,
+                        new Ok(reservation)
+                    ];
             }
-        }
-    });
+        });
+    })();
 };
-const recreateReservationInvoiceAndUpdateReservation = async (previousReservation, { invoiceId, ...body }, vehicle, payer)=>{
-    const invoiceResult = await createReservationInvoice({
-        ...body,
-        reservationId: previousReservation.id,
-        vehicle,
-        payer
-    });
-    if (!invoiceResult.ok) {
-        return invoiceResult;
-    }
-    const invoice = invoiceResult.val;
-    const updatedReservation = await prisma.subscriptionReservation.update({
-        where: {
-            id: previousReservation.id
-        },
-        data: {
-            invoice: {
-                connect: {
-                    id: invoice.id
-                }
+var createReservation = function(param) {
+    var reservationId = param.reservationId, invoiceId = param.invoiceId, subscribingUserId = param.subscribingUserId, vehicleId = param.vehicleId, businessId = param.businessId, plan = param.plan, mileagePackage = param.mileagePackage, couponCode = param.couponCode, referralCode = param.referralCode, analytics = param.analytics, deliveryAddresses = param.deliveryAddresses, deliveryDate = param.deliveryDate, asBusiness = param.asBusiness, source = param.source;
+    return _async_to_generator(function() {
+        return _ts_generator(this, function(_state) {
+            switch(_state.label){
+                case 0:
+                    return [
+                        4,
+                        prisma.subscriptionReservation.create({
+                            data: _object_spread_props(_object_spread(_object_spread_props(_object_spread({
+                                id: reservationId,
+                                invoice: {
+                                    connect: {
+                                        id: invoiceId
+                                    }
+                                },
+                                user: {
+                                    connect: {
+                                        id: subscribingUserId
+                                    }
+                                },
+                                vehicle: {
+                                    connect: {
+                                        id: vehicleId
+                                    }
+                                }
+                            }, businessId ? {
+                                business: {
+                                    connect: {
+                                        id: businessId
+                                    }
+                                }
+                            } : undefined), {
+                                plan: plan,
+                                mileagePackage: mileagePackage,
+                                couponCode: couponCode,
+                                deliveryAddresses: deliveryAddresses,
+                                deliveryDate: deliveryDate
+                            }), referralCode ? {
+                                referral: {
+                                    connect: {
+                                        id: referralCode
+                                    }
+                                }
+                            } : undefined), {
+                                asBusiness: !!asBusiness,
+                                source: source,
+                                metadata: {
+                                    analytics: analytics
+                                }
+                            })
+                        })
+                    ];
+                case 1:
+                    return [
+                        2,
+                        _state.sent()
+                    ];
             }
-        }
-    });
-    return new Ok(updatedReservation);
+        });
+    })();
+};
+var recreateReservationInvoiceAndUpdateReservation = function(previousReservation, body, vehicle, payer) {
+    return _async_to_generator(function() {
+        var invoiceResult, invoice, updatedReservation;
+        return _ts_generator(this, function(_state) {
+            switch(_state.label){
+                case 0:
+                    return [
+                        4,
+                        createReservationInvoice(_object_spread_props(_object_spread({}, body), {
+                            reservationId: previousReservation.id,
+                            vehicle: vehicle,
+                            payer: payer
+                        }))
+                    ];
+                case 1:
+                    invoiceResult = _state.sent();
+                    if (!invoiceResult.ok) {
+                        return [
+                            2,
+                            invoiceResult
+                        ];
+                    }
+                    invoice = invoiceResult.val;
+                    return [
+                        4,
+                        prisma.subscriptionReservation.update({
+                            where: {
+                                id: previousReservation.id
+                            },
+                            data: {
+                                invoice: {
+                                    connect: {
+                                        id: invoice.id
+                                    }
+                                }
+                            }
+                        })
+                    ];
+                case 2:
+                    updatedReservation = _state.sent();
+                    return [
+                        2,
+                        new Ok(updatedReservation)
+                    ];
+            }
+        });
+    })();
 };