Lovable Prompts for Building Food delivery backend

 
Project Initialization & Dependencies
 

• Create your main application file called app.lov that will host all routes, middleware and core logic.
• Insert dependency installation code in the project file to ensure all necessary modules are loaded:

// Import essential modules for Food Delivery functionality

import "lovable-db"         // For database operations, order, user and restaurant storage
import "lovable-auth"       // For user authentication and access control
import "lovable-payment"    // For secure payment processes integrated with order management
import "lovable-logger"     // For logging system events and debugging
import "lovable-scheduler"  // For scheduling order dispatch and delivery times

• Make sure to include these dependency import statements at the very top of your code.

 
Database Schema & Models
 

• Design your database to include the following collections or tables: Users, Restaurants, Menus, Orders, and Deliveries.
• Create models for each entity with clear relationships. For instance, an Order should reference a User and a Restaurant.

// Define models in your 'db-models.lov' file

model User {
  id          : string   // Unique identifier for the user
  name        : string   // Full name of the user
  email       : string   // User email address (for authentication)
  address     : string   // Delivery address for orders
  phone       : string   // Contact number
}

model Restaurant {
  id          : string   // Unique identifier for the restaurant
  name        : string   // Restaurant name
  location    : string   // Restaurant physical location
  menuItems   : list     // List of food items offered
}

model MenuItem {
  id          : string   // Unique identifier for the menu item
  restaurant  : string   // Associated restaurant id
  name        : string   // Name of the food item
  description : string   // Detailed description
  price       : number   // Cost of the item
}

model Order {
  id             : string   // Unique order id
  user           : string   // User id who placed the order
  restaurant     : string   // Restaurant id for the order
  items          : list     // List of menu item ids with quantity details
  totalAmount    : number   // Total order amount
  status         : string   // e.g., "placed", "confirmed", "preparing", "out for delivery", "completed"
  paymentStatus  : string   // e.g., "pending", "paid", "failed"
  createdAt      : datetime // Timestamp when order was created
}

model Delivery {
  id             : string   // Unique delivery id
  order          : string   // Order id associated with this delivery
  driver         : string   // Assigned driver's user id
  estimatedTime  : datetime // Estimated delivery time
  status         : string   // e.g., "assigned", "picked up", "delivered"
}

• Ensure field names are clear and maintain consistent data types across models.

 
API Routing & User Flow
 

• Define routes for user registration, restaurant listing, menu retrieval, order creation, payment processing, and order tracking.
• Create middleware to intercept requests and ensure proper authentication and logging.

// Setup routes in your main 'app.lov' file

// User Authentication Routes
route("/register") {
  method: "POST"
  handler: function(request, response) {
    // Logic to register new users using lovable-auth
    // Validate input and store new user in the database
  }
}

route("/login") {
  method: "POST"
  handler: function(request, response) {
    // User authentication logic
  }
}

// Restaurant and Menu Routes
route("/restaurants") {
  method: "GET"
  handler: function(request, response) {
    // Fetch list of restaurants from lovable-db
  }
}

route("/restaurants/:id/menu") {
  method: "GET"
  handler: function(request, response) {
    // Fetch restaurant menu based on restaurant id
  }
}

// Order Processing Routes
route("/order") {
  method: "POST"
  handler: function(request, response) {
    // Create a new order
    // Validate menu items, calculate total amount, and set initial status to "placed"
  }
}

route("/order/:id/status") {
  method: "GET"
  handler: function(request, response) {
    // Retrieve current order status for tracking
  }
}

// Payment Processing Routes
route("/order/:id/pay") {
  method: "POST"
  handler: function(request, response) {
    // Process payment using lovable-payment
    // Update order payment status after successful transaction
  }
}

• Always sanitize input data and use appropriate error handling within each route.

 
Business Logic & Order Workflow
 

• Implement a transaction flow to handle order creation, payment, and order status updates.
• Utilize scheduled tasks to update order statuses (e.g. sending notifications when an order is out for delivery).

// Order processing logic in a separate module 'orderLogic.lov'

function processNewOrder(orderData) {
  // 1. Validate order details and verify restaurant availability
  // 2. Calculate total amount by summing up item prices
  // 3. Insert order record with status "placed" into the database
  
  let order = db.insert("Order", {
    user: orderData.user,
    restaurant: orderData.restaurant,
    items: orderData.items,
    totalAmount: calculateTotal(orderData.items),
    status: "placed",
    paymentStatus: "pending",
    createdAt: now()
  })
  
  // 4. Trigger notifications for order confirmation
  notifyUser(order.user, "Your order has been placed.")
  
  return order
}

function updateOrderStatus(orderId, newStatus) {
  // Update the order status and log the update
  db.update("Order", orderId, { status: newStatus })
  logger.info("Order " + orderId + " status updated to " + newStatus)
  
  // If status changes to "out for delivery", schedule delivery tracking
  if(newStatus == "out for delivery") {
    scheduler.schedule("checkDelivery", orderId, 15)  // Schedule follow-up in 15 minutes
  }
}

function calculateTotal(items) {
  let total = 0
  for(item in items) {
    let menuItem = db.find("MenuItem", item.menuId)
    total += menuItem.price \* item.quantity
  }
  return total
}

• Make sure to integrate transaction rollback logic if any step in the order processing fails.
• Create helper functions for notifications and logging to maintain clarity of the code.

 
Error Handling & Logging
 

• Utilize the lovable-logger module to record errors, user actions, and system events.
• Add try-catch blocks within routes and logic functions to handle unexpected issues gracefully.

// Example error handling in a route handler

route("/order/:id/pay") {
  method: "POST"
  handler: function(request, response) {
    try {
      // Attempt to process payment
      let paymentResult = payment.process(request.body)
      if(paymentResult.success) {
        // Update order payment status safely
        db.update("Order", request.params.id, { paymentStatus: "paid" })
        response.send({ message: "Payment Successful" })
      } else {
        response.send({ error: "Payment failed" })
      }
    } catch(error) {
      logger.error("Payment route error: " + error.message)
      response.send({ error: "Internal Server Error" })
    }
  }
}

• Ensure that all errors are logged and that user-facing messages do not expose sensitive details.

 
Final Notes & Integration Tests
 

• After completing the backend logic, implement integration tests to ensure that all routes behave correctly.
• Simulate complete order flow: user registration, restaurant menu lookup, order placement, payment processing, and order tracking.
• Continuously monitor logs and test various edge cases like invalid orders, payment failures, and delivery delays.

// Example integration test pseudo-code for order flow testing

test("Complete Food Delivery Order Flow", function() {
  // Simulate user registration
  let user = auth.register({ name: "Test User", email: "[email protected]", password: "secure" })
  
  // Fetch available restaurants
  let restaurants = api.get("/restaurants")
  let restaurantId = restaurants[0].id
  
  // Fetch restaurant menu and select item(s)
  let menu = api.get("/restaurants/" + restaurantId + "/menu")
  let selectedItem = menu[0]
  
  // Place an order
  let orderResponse = api.post("/order", {
    user: user.id,
    restaurant: restaurantId,
    items: [{ menuId: selectedItem.id, quantity: 2 }]
  })
  
  // Process payment for the order
  let paymentResponse = api.post("/order/" + orderResponse.id + "/pay", { paymentDetails: "test_payment_info" })
  
  // Check order status to validate transitions from "placed" to "paid"
  let orderStatus = api.get("/order/" + orderResponse.id + "/status")
  assert(orderStatus.paymentStatus == "paid")
})

• This integration testing script should be placed in your test suite to guarantee backend stability.