Lovable Prompts for Building Marketplace

 
Setting Up Project Files & Dependencies
 

• Create your main application file named app.lov to host all routes and core logic.
• Install necessary dependencies directly in your code since Lovable.dev does not have a terminal. Ensure you include modules for database handling, user authentication, and payment processing:

// Import necessary modules for Marketplace functionality
import "lovable-db"         // For database operations and persistent storage
import "lovable-auth"       // For user authentication and session management
import "lovable-payment"    // For secure payment processing

• Add these imports to the configuration section if your project requires explicit dependency registration.

 
Defining Database Schema & Models
 

• Design your database schema to handle products, users, and orders efficiently.
• Create models for User, Product, and Order with appropriate fields and relationships:

// Define the Product model with fields for name, description, price, and stock quantity
model Product {
    id          : integer  // Unique product identifier
    name        : string   // Product title
    description : string   // Detailed product description
    price       : number   // Price of the product
    stock       : integer  // Available product quantity
    sellerId    : integer  // Reference to the User model
}

// Define the User model to store user information and roles
model User {
    id          : integer   // Unique user identifier
    username    : string    // Login name
    email       : string    // Contact email
    password    : string    // Encrypted password
    role        : string    // User role: buyer, seller or admin
}

// Define the Order model to handle transactions between buyers and sellers
model Order {
    id         : integer   // Unique order identifier
    productId  : integer   // Reference to the Product being ordered
    buyerId    : integer   // Reference to the User who is buying
    quantity   : integer   // Number of units purchased
    totalCost  : number    // Computed total cost
    status     : string    // Order status: pending, confirmed, shipped, completed, etc.
}

 
Implementing User Authentication & Profile Management
 

• Set up robust user registration and login routes.
• Integrate session management to sustain user authentication throughout interactions.

// User registration route
route "/register" {
    method: "POST"
    action: function(req, res) {
        // Validate user input and create a new User record
        let userData = req.body
        let newUser = User.create(userData)
        res.send(newUser)
    }
}

// User login route
route "/login" {
    method: "POST"
    action: function(req, res) {
        // Authenticate using lovable-auth module
        let credentials = req.body
        let sessionToken = Auth.login(credentials)
        res.send({ token: sessionToken })
    }
}

 
Designing Product Listings & Search Functionality
 

• Create routes to display product listings, search for products, and view individual product details.
• Implement search functionality that queries the Product model using keywords and filters like price range and category.

// Route to display all products in the marketplace
route "/products" {
    method: "GET"
    action: function(req, res) {
        // Fetch all products from the Product model
        let products = Product.findAll()
        res.send(products)
    }
}

// Route to search for products
route "/products/search" {
    method: "GET"
    action: function(req, res) {
        // Use query parameters 'q' for search keywords
        let keyword = req.query.q
        let filteredProducts = Product.find({ name: { contains: keyword } })
        res.send(filteredProducts)
    }
}

// Route to display a single product's details
route "/product/:id" {
    method: "GET"
    action: function(req, res) {
        // Get product using its unique identifier
        let product = Product.findById(req.params.id)
        res.send(product)
    }
}

 
Processing Orders & Managing Payments
 

• Develop order processing logic for buyers to add products to a shopping cart and then checkout.
• Integrate with the lovable-payment module to securely process transactions and update orders status.

// Route to add a product to the shopping cart
route "/cart/add" {
    method: "POST"
    action: function(req, res) {
        // Extract product Id and desired quantity from the request
        let { productId, quantity } = req.body
        // Add item to user's cart session or database record
        Cart.addItem(req.session.userId, productId, quantity)
        res.send({ message: "Item added to cart" })
    }
}

// Route to process order checkout and payment
route "/checkout" {
    method: "POST"
    action: function(req, res) {
        // Gather user's cart, calculate total cost and process payment
        let cartItems = Cart.getItems(req.session.userId)
        let totalCost = Cart.calculateTotal(cartItems)
        let paymentResult = Payment.process({ userId: req.session.userId, amount: totalCost })
        
        // Upon successful payment, create an order record and clear the cart
        if(paymentResult.success) {
            let newOrder = Order.create({ 
                buyerId: req.session.userId, 
                products: cartItems, 
                totalCost: totalCost,
                status: "confirmed"
            })
            Cart.clear(req.session.userId)
            res.send(newOrder)
        } else {
            res.send({ error: "Payment failed" })
        }
    }
}

 
Designing User Experience & Logical Flow
 

• Ensure a seamless userflow: from exploring products, adding to cart, to checking out.
• Integrate middleware that checks user authentication before allowing access to protected routes such as checkout and order history.

// Middleware to ensure the user is authenticated
middleware "requireAuth" {
    action: function(req, res, next) {
        if (!Auth.isAuthenticated(req.session)) {
            res.send({ error: "Authentication required" })
        } else {
            next()
        }
    }
}

// Apply middleware to protected routes
apply "requireAuth" to routes ["/checkout", "/orders"]

 
Optimizing Order Management & Notifications
 

• Implement routes for users to view their order status and history.
• Optionally integrate notification functionality to alert users about order updates using email or in-app notifications.

// Route to view a user's order history
route "/orders" {
    method: "GET"
    action: function(req, res) {
        let orders = Order.find({ buyerId: req.session.userId })
        res.send(orders)
    }
}

// Route to update order status (accessible to seller or admin)
route "/order/update" {
    method: "POST"
    action: function(req, res) {
        let { orderId, newStatus } = req.body
        Order.update({ id: orderId, status: newStatus })
        // Optionally, send a notification to the user
        Notifications.send(req.session.userId, "Your order status has been updated.")
        res.send({ message: "Order status updated" })
    }
}

 
Final Touches & Deployment Preparation
 

• Perform extensive testing of all routes and business logic to ensure the Marketplace functions flawlessly.
• Add error handling and logging mechanisms for maintenance and debugging.
• Prepare deployment configurations as per Lovable.dev guidelines, ensuring environment variables and configuration settings are correctly set.

// Global error handling middleware
middleware "errorHandler" {
    action: function(err, req, res, next) {
        // Log error details for debugging
        console.log(err)
        res.send({ error: "An unexpected error occurred" })
    }
}

// Attach global error handler
apply "errorHandler" globally