From Zero to Storefront: My Journey Building a Car Rental Website and Mobile App

import 'dotenv/config'

import process from 'node:process'

import fs from 'node:fs/promises'

import http from 'node:http'

import https, { ServerOptions } from 'node:https'

import * as env from './config/env.config'

import * as databaseHelper from './common/databaseHelper'

import app from './app'

import * as logger from './common/logger'



if (

  await databaseHelper.connect(env.DB_URI, env.DB_SSL, env.DB_DEBUG)

  && await databaseHelper.initialize()

) {

  let server: http.Server | https.Server



  if (env.HTTPS) {

    https.globalAgent.maxSockets = Number.POSITIVE_INFINITY

    const privateKey = await fs.readFile(env.PRIVATE_KEY, 'utf8')

    const certificate = await fs.readFile(env.CERTIFICATE, 'utf8')

    const credentials: ServerOptions = { key: privateKey, cert: certificate }

    server = https.createServer(credentials, app)



    server.listen(env.PORT, () => {

      logger.info('HTTPS server is running on Port', env.PORT)

    })

  } else {

    server = app.listen(env.PORT, () => {

      logger.info('HTTP server is running on Port', env.PORT)

    })

  }



  const close = () => {

    logger.info('Gracefully stopping...')

    server.close(async () => {

      logger.info(`HTTP${env.HTTPS ? 'S' : ''} server closed`)

      await databaseHelper.close(true)

      logger.info('MongoDB connection closed')

      process.exit(0)

    })

  }



  ['SIGINT', 'SIGTERM', 'SIGQUIT'].forEach((signal) => process.on(signal, close))

}

import express from 'express'

import compression from 'compression'

import helmet from 'helmet'

import nocache from 'nocache'

import cookieParser from 'cookie-parser'

import i18n from './lang/i18n'

import * as env from './config/env.config'

import cors from './middlewares/cors'

import allowedMethods from './middlewares/allowedMethods'

import supplierRoutes from './routes/supplierRoutes'

import bookingRoutes from './routes/bookingRoutes'

import locationRoutes from './routes/locationRoutes'

import notificationRoutes from './routes/notificationRoutes'

import carRoutes from './routes/carRoutes'

import userRoutes from './routes/userRoutes'

import stripeRoutes from './routes/stripeRoutes'

import countryRoutes from './routes/countryRoutes'

import * as helper from './common/helper'



const app = express()



app.use(helmet.contentSecurityPolicy())

app.use(helmet.dnsPrefetchControl())

app.use(helmet.crossOriginEmbedderPolicy())

app.use(helmet.frameguard())

app.use(helmet.hidePoweredBy())

app.use(helmet.hsts())

app.use(helmet.ieNoOpen())

app.use(helmet.noSniff())

app.use(helmet.permittedCrossDomainPolicies())

app.use(helmet.referrerPolicy())

app.use(helmet.xssFilter())

app.use(helmet.originAgentCluster())

app.use(helmet.crossOriginResourcePolicy({ policy: 'cross-origin' }))

app.use(helmet.crossOriginOpenerPolicy())



app.use(nocache())

app.use(compression({ threshold: 0 }))

app.use(express.urlencoded({ limit: '50mb', extended: true }))

app.use(express.json({ limit: '50mb' }))



app.use(cors())

app.options('*', cors())

app.use(cookieParser(env.COOKIE_SECRET))

app.use(allowedMethods)



app.use('/', supplierRoutes)

app.use('/', bookingRoutes)

app.use('/', locationRoutes)

app.use('/', notificationRoutes)

app.use('/', carRoutes)

app.use('/', userRoutes)

app.use('/', stripeRoutes)

app.use('/', countryRoutes)



i18n.locale = env.DEFAULT_LANGUAGE



await helper.mkdir(env.CDN_USERS)

await helper.mkdir(env.CDN_TEMP_USERS)

await helper.mkdir(env.CDN_CARS)

await helper.mkdir(env.CDN_TEMP_CARS)

await helper.mkdir(env.CDN_LOCATIONS)

await helper.mkdir(env.CDN_TEMP_LOCATIONS)



export default app

import express from 'express'

import routeNames from '../config/countryRoutes.config'

import authJwt from '../middlewares/authJwt'

import * as countryController from '../controllers/countryController'



const routes = express.Router()



routes.route(routeNames.validate).post(authJwt.verifyToken, countryController.validate)

routes.route(routeNames.create).post(authJwt.verifyToken, countryController.create)

routes.route(routeNames.update).put(authJwt.verifyToken, countryController.update)

routes.route(routeNames.delete).delete(authJwt.verifyToken, countryController.deleteCountry)

routes.route(routeNames.getCountry).get(authJwt.verifyToken, countryController.getCountry)

routes.route(routeNames.getCountries).get(authJwt.verifyToken, countryController.getCountries)

routes.route(routeNames.getCountriesWithLocations).get(countryController.getCountriesWithLocations)

routes.route(routeNames.checkCountry).get(authJwt.verifyToken, countryController.checkCountry)

routes.route(routeNames.getCountryId).get(authJwt.verifyToken, countryController.getCountryId)



export default routes

const routes = {

  validate: '/api/validate-country',

  create: '/api/create-country',

  update: '/api/update-country/:id',

  delete: '/api/delete-country/:id',

  getCountry: '/api/country/:id/:language',

  getCountries: '/api/countries/:page/:size/:language',

  getCountriesWithLocations: '/api/countries-with-locations/:language/:imageRequired/:minLocations',

  checkCountry: '/api/check-country/:id',

  getCountryId: '/api/country-id/:name/:language',

}



export default routes

import { Schema, model } from 'mongoose'

import * as env from '../config/env.config'



const countrySchema = new Schema<env.Country>(

  {

    values: {

      type: [Schema.Types.ObjectId],

      ref: 'LocationValue',

      required: [true, "can't be blank"],

      validate: (value: any): boolean => Array.isArray(value),

    },

  },

  {

    timestamps: true,

    strict: true,

    collection: 'Country',

  },

)



const Country = model<env.Country>('Country', countrySchema)



export default Country

export interface Country extends Document {

  values: Types.ObjectId[]

  name?: string

}

import { Schema, model } from 'mongoose'

import * as env from '../config/env.config'



const locationValueSchema = new Schema<env.LocationValue>(

  {

    language: {

      type: String,

      required: [true, "can't be blank"],

      index: true,

      trim: true,

      lowercase: true,

      minLength: 2,

      maxLength: 2,

    },

    value: {

      type: String,

      required: [true, "can't be blank"],

      index: true,

      trim: true,

    },

  },

  {

    timestamps: true,

    strict: true,

    collection: 'LocationValue',

  },

)



const LocationValue = model<env.LocationValue>('LocationValue', locationValueSchema)



export default LocationValue

export interface LocationValue extends Document {

  language: string

  value: string

}

export const create = async (req: Request, res: Response) => {

  const { body }: { body: bookcarsTypes.CountryName[] } = req

  const names = body



  try {

    const values: string[] = []

    for (const name of names) {

      const countryValue = new LocationValue({

        language: name.language,

        value: name.name,

      })

      await countryValue.save()

      values.push(countryValue.id)

    }



    const country = new Country({ values })

    await country.save()

    return res.send(country)

  } catch (err) {

    logger.error(`[country.create] ${i18n.t('DB_ERROR')} ${JSON.stringify(req.body)}`, err)

    return res.status(400).send(i18n.t('DB_ERROR') + err)

  }

}

import React, { lazy, Suspense } from 'react'

import { BrowserRouter as Router, Route, Routes } from 'react-router-dom'

import env from '@/config/env.config'

import { GlobalProvider } from '@/context/GlobalContext'

import { init as initGA } from '@/common/ga4'



if (env.GOOGLE_ANALYTICS_ENABLED) {

  initGA()

}



const SignIn = lazy(() => import('@/pages/SignIn'))

const SignUp = lazy(() => import('@/pages/SignUp'))

const Activate = lazy(() => import('@/pages/Activate'))

const ForgotPassword = lazy(() => import('@/pages/ForgotPassword'))

const ResetPassword = lazy(() => import('@/pages/ResetPassword'))

const Home = lazy(() => import('@/pages/Home'))

const Search = lazy(() => import('@/pages/Search'))

const Checkout = lazy(() => import('@/pages/Checkout'))

const CheckoutSession = lazy(() => import('@/pages/CheckoutSession'))

const Bookings = lazy(() => import('@/pages/Bookings'))

const Booking = lazy(() => import('@/pages/Booking'))

const Settings = lazy(() => import('@/pages/Settings'))

const Notifications = lazy(() => import('@/pages/Notifications'))

const ToS = lazy(() => import('@/pages/ToS'))

const About = lazy(() => import('@/pages/About'))

const ChangePassword = lazy(() => import('@/pages/ChangePassword'))

const Contact = lazy(() => import('@/pages/Contact'))

const NoMatch = lazy(() => import('@/pages/NoMatch'))

const Locations = lazy(() => import('@/pages/Locations'))

const Suppliers = lazy(() => import('@/pages/Suppliers'))



const App = () => (

  <GlobalProvider>

    <Router>

      <div className="app">

        <Suspense fallback={<></>}>

          <Routes>

            <Route path="/sign-in" element={<SignIn />} />

            <Route path="/sign-up" element={<SignUp />} />

            <Route path="/activate" element={<Activate />} />

            <Route path="/forgot-password" element={<ForgotPassword />} />

            <Route path="/reset-password" element={<ResetPassword />} />

            <Route path="/" element={<Home />} />

            <Route path="/search" element={<Search />} />

            <Route path="/checkout" element={<Checkout />} />

            <Route path="/checkout-session/:sessionId" element={<CheckoutSession />} />

            <Route path="/bookings" element={<Bookings />} />

            <Route path="/booking" element={<Booking />} />

            <Route path="/settings" element={<Settings />} />

            <Route path="/notifications" element={<Notifications />} />

            <Route path="/change-password" element={<ChangePassword />} />

            <Route path="/about" element={<About />} />

            <Route path="/tos" element={<ToS />} />

            <Route path="/contact" element={<Contact />} />

            <Route path="/locations" element={<Locations />} />

            <Route path="/suppliers" element={<Suppliers />} />



            <Route path="*" element={<NoMatch />} />

          </Routes>

        </Suspense>

      </div>

    </Router>

  </GlobalProvider>

)



export default App

{

  "extends": "expo/tsconfig.base",

  "compilerOptions": {

    "strict": true,

    "typeRoots": [

      "./types"

    ]

  }

}

import 'react-native-gesture-handler'

import React, { useCallback, useEffect, useRef, useState } from 'react'

import { RootSiblingParent } from 'react-native-root-siblings'

import { NavigationContainer, NavigationContainerRef } from '@react-navigation/native'

import { StatusBar as ExpoStatusBar } from 'expo-status-bar'

import { SafeAreaProvider } from 'react-native-safe-area-context'

import { Provider } from 'react-native-paper'

import * as SplashScreen from 'expo-splash-screen'

import * as Notifications from 'expo-notifications'

import { StripeProvider } from '@stripe/stripe-react-native'

import DrawerNavigator from './components/DrawerNavigator'

import * as helper from './common/helper'

import * as NotificationService from './services/NotificationService'

import * as UserService from './services/UserService'

import { GlobalProvider } from './context/GlobalContext'

import * as env from './config/env.config'



Notifications.setNotificationHandler({

  handleNotification: async () => ({

    shouldShowAlert: true,

    shouldPlaySound: true,

    shouldSetBadge: true,

  }),

})



//

// Prevent native splash screen from autohiding before App component declaration

//

SplashScreen.preventAutoHideAsync()

  .then((result) => console.log(`SplashScreen.preventAutoHideAsync() succeeded: ${result}`))

  .catch(console.warn) // it's good to explicitly catch and inspect any error



const App = () => {

  const [appIsReady, setAppIsReady] = useState(false)



  const responseListener = useRef<Notifications.Subscription>()

  const navigationRef = useRef<NavigationContainerRef<StackParams>>(null)



  useEffect(() => {

    const register = async () => {

      const loggedIn = await UserService.loggedIn()

      if (loggedIn) {

        const currentUser = await UserService.getCurrentUser()

        if (currentUser?._id) {

          await helper.registerPushToken(currentUser._id)

        } else {

          helper.error()

        }

      }

    }



    //

    // Register push notifiations token

    //

    register()



    //

    // This listener is fired whenever a user taps on or interacts with a notification (works when app is foregrounded, backgrounded, or killed)

    //

    responseListener.current = Notifications.addNotificationResponseReceivedListener(async (response) => {

      try {

        if (navigationRef.current) {

          const { data } = response.notification.request.content



          if (data.booking) {

            if (data.user && data.notification) {

              await NotificationService.markAsRead(data.user, [data.notification])

            }

            navigationRef.current.navigate('Booking', { id: data.booking })

          } else {

            navigationRef.current.navigate('Notifications', {})

          }

        }

      } catch (err) {

        helper.error(err, false)

      }

    })



    return () => {

      Notifications.removeNotificationSubscription(responseListener.current!)

    }

  }, [])



  setTimeout(() => {

    setAppIsReady(true)

  }, 500)



  const onReady = useCallback(async () => {

    if (appIsReady) {

      //

      // This tells the splash screen to hide immediately! If we call this after

      // `setAppIsReady`, then we may see a blank screen while the app is

      // loading its initial state and rendering its first pixels. So instead,

      // we hide the splash screen once we know the root view has already

      // performed layout.

      //

      await SplashScreen.hideAsync()

    }

  }, [appIsReady])



  if (!appIsReady) {

    return null

  }



  return (

    <GlobalProvider>

      <SafeAreaProvider>

        <Provider>

          <StripeProvider publishableKey={env.STRIPE_PUBLISHABLE_KEY} merchantIdentifier={env.STRIPE_MERCHANT_IDENTIFIER}>

            <RootSiblingParent>

              <NavigationContainer ref={navigationRef} onReady={onReady}>

                <ExpoStatusBar style="light" backgroundColor="rgba(0, 0, 0, .9)" />

                <DrawerNavigator />

              </NavigationContainer>

            </RootSiblingParent>

          </StripeProvider>

        </Provider>

      </SafeAreaProvider>

    </GlobalProvider>

  )

}



export default App