switch to prisma

db/index.ts

@@ -1,129 +1,121 @@
-import * as mongoose from 'mongoose'
-import BookingModel, { Booking, BookingDocument } from './booking'
-import BillModel, { Bill } from './bill'
+import { BookingStatus, Booking, PrismaClient, Prisma } from '@prisma/client'
+
+const prisma = new PrismaClient()
+
 import { getBookedDays as calendarGetBookedDays } from '../lib/googlecalendar'
-import { BOOKING_STATUS } from './enums'
 import { uniqueFilter } from '../helpers/array'
-
-export const MONGO_URI = process.env.MONGO_URI
-
-mongoose.connect(process.env.MONGO_URI, {
-  serverSelectionTimeoutMS: 3000,
-})
+import { dateFormatBackend, getDays, nowInTz } from '../helpers/date'
 
 export async function getBookedDays(
   uuidsToIngore?: string[]
-): Promise<string[]> {
-  const [bookedInDatabase, bookedInCalendar] = await Promise.all([
-    BookingModel.findBookedDays(uuidsToIngore),
+) {
+  const [bookingsInDbRaw, bookingsInCalendar] = await Promise.all([
+    prisma.booking.findMany({
+      where: {
+        uuid: { notIn: uuidsToIngore },
+        startDate: { gte: dateFormatBackend(nowInTz()) },
+        status: { notIn: [BookingStatus.REJECTED, BookingStatus.CANCELED] }
+      },
+      select: {
+        startDate: true,
+        endDate: true,
+      },
+    }),
     calendarGetBookedDays(),
   ])
-  return [...bookedInDatabase, ...bookedInCalendar].filter(uniqueFilter).sort()
+
+  const bookingsInDb = bookingsInDbRaw.map(booking => getDays(booking)).flat();
+
+  return [...bookingsInDb, ...bookingsInCalendar].filter(uniqueFilter).sort()
 }
 
-export async function getBookingByUUID(uuid: string): Promise<BookingDocument> {
-  return BookingModel.findOne({ uuid })
+export function getBookingByUUID(uuid: string) {
+  // TODO: can we ignore canceled and rejected ones ?
+  return prisma.booking.findUniqueOrThrow({
+    where: {
+      uuid,
+    },
+    include: {
+      bill: true
+    }
+  })
 }
 
-export async function getBookings({
-  status = [BOOKING_STATUS.CONFIRMED, BOOKING_STATUS.REQUESTED],
+export function getBookings({
+  status = [
+    BookingStatus.REQUESTED,
+    BookingStatus.CONFIRMED,
+  ],
   startDateGreaterThan = '2000-01-01T00:00:00Z',
-}: { status?: BOOKING_STATUS[]; startDateGreaterThan?: string } = {}): Promise<
-  BookingDocument[]
-> {
-  return await BookingModel.find({
-    status: { $in: status },
-    startDate: { $gte: startDateGreaterThan },
-  })
-    .sort({ startDate: -1 })
-    .exec()
+}
+  : { status?: BookingStatus[]; startDateGreaterThan?: string } = {}) {
+  return prisma.booking.findMany({
+    where: {
+      startDate: { gte: startDateGreaterThan },
+      status: { notIn: status }
+    },
+  });
 }
 
-export async function createBooking({
-  startDate,
-  endDate,
-  purpose,
-  org,
-  destination,
-  name,
-  email,
-  phone,
-  street,
-  zip,
-  city,
-}: Booking): Promise<Booking> {
-  const booking = new BookingModel({
-    startDate,
-    endDate,
-    purpose,
-    org,
-    destination,
-    name,
-    email,
-    phone,
-    street,
-    zip,
-    city,
-  })
-
-  await booking.save()
-  return booking.toJSON<Booking>()
+export function createBooking(data: Booking) {
+  return prisma.booking.create({
+    data
+  });
 }
 
 export async function patchBooking(
+  uuid: string,
+  data: Prisma.BookingCreateInput
+) {
+  const current = await prisma.booking.update({
+    where: { uuid },
+    data
+  });
+  const previous = { ...current, ...data }
+  return { current, previous }
+
+}
+
+export function createBill(
   bookingUUID: string,
-  bookingData: Booking
-): Promise<{ current: Booking; previous: Booking }> {
-  const booking = await getBookingByUUID(bookingUUID)
-  const oldBooking = booking.toJSON<Booking>()
-  booking.set(bookingData)
-  await booking.save()
-
-  return { current: booking.toJSON<Booking>(), previous: oldBooking }
+  data: Prisma.BillCreateInput,
+) {
+  return prisma.bill.create({
+    data: {
+      ...data,
+      booking: {
+        connect: { uuid: bookingUUID }
+      }
+    }
+  });
 }
 
-export async function createBill(
+export function patchBill(
   bookingUUID: string,
-  billData: Bill
-): Promise<Bill> {
-  const booking = await getBookingByUUID(bookingUUID)
-
-  const bill = new BillModel()
-  bill.set(billData)
-
-  await bill.save()
-
-  booking.bill = bill._id
-  await booking.save()
-
-  return bill.toJSON<Bill>()
+  data: Prisma.BillUncheckedUpdateInput,
+) {
+  const { id, ...rest } = data;
+  return prisma.bill.update({
+    where: {
+    },
+    data: {
+      ...rest,
+      booking: {
+        connect: { uuid: bookingUUID }
+      }
+    }
+  });
 }
 
-export async function patchBill(
-  bookingUUID: string,
-  billData: Bill
-): Promise<Bill> {
-  const booking = await getBookingByUUID(bookingUUID)
-  const bill =
-    (booking.bill && (await BillModel.findById(booking.bill))) ||
-    (await BillModel.create({}))
+export async function getMilageMax() {
+  const { milageEnd } = await prisma.bill.findFirst({
+    select: { milageEnd: true },
+    orderBy: [
+      {
+        milageEnd: 'desc',
+      },
+    ],
+  });
 
-  bill.set(billData)
-  await bill.save()
-
-  if (booking.bill !== bill._id) {
-    booking.bill = bill._id
-    await booking.save()
-  }
-
-  return bill.toJSON<Bill>()
-}
-
-export async function getMilageMax(): Promise<number> {
-  const billMaxMilageEnd = await BillModel.findOne({})
-    .sort('-milageEnd')
-    .select('milageEnd')
-    .exec()
-
-  return billMaxMilageEnd?.milageEnd || 0
+  return milageEnd || 0;
 }