Lovable Prompts for Building Auction platform

 
Setting Up Project Files & Dependencies
 

• Create your main application file named app.lov to serve as the entry point for the Auction Platform.
• Add dependency installation directly in your code since Lovable.dev does not have a terminal. Include required modules:

// Import necessary modules for Auction Platform functionality
import "lovable-db"            // For database operations and persistent storage
import "lovable-auth"          // For user authentication and session management
import "lovable-realtime"      // For real-time WebSocket-based updates
import "lovable-payment"       // For secure payment processing

• Ensure these dependencies are configured in your project's configuration section if applicable.

 
Defining Data Models
 

• Define models for Auction, Bid, and User to represent core entities in the platform.

// Auction model to store auction details and status
model Auction {
    id: string
    title: string
    description: string
    startPrice: number
    currentPrice: number
    bidIncrement: number
    endTime: datetime
    status: enum { active, closed }
    sellerId: string
}

// Bid model to log each bid on an auction item
model Bid {
    id: string
    auctionId: string
    bidderId: string
    bidAmount: number
    bidTime: datetime
}

// User model to manage user profile, authentication, and account balance
model User {
    id: string
    username: string
    password: string
    email: string
    balance: number
}

 
Implementing Authentication & Access Control
 

• Create routes for user registration and login utilizing the lovable-auth module.
• Establish middleware to ensure that only authenticated users can access auction functionalities.

// Route for user registration
route "/register" {
    // Execute registration logic using lovable-auth module
    use "lovable-auth".register
}

// Route for user login
route "/login" {
    // Execute login logic using lovable-auth module
    use "lovable-auth".login
}

// Middleware to enforce authenticated access on restricted routes
middleware authenticateUser using "lovable-auth".requireAuth

 
Creating Auction Listings & Detail Pages
 

• Develop a route to display a list of active auctions with their key details.
• Create a detail page route for individual auctions, showing description, current bid, and countdown timer.

// Route to list all active auctions
route "/auctions" {
    activeAuctions = db.query(Auction where status == "active")
    render auctionsPage(auctions: activeAuctions)
}

// Route for auction detail page
route "/auction/{auctionId}" {
    auction = db.get(Auction, auctionId)
    bids = db.query(Bid where auctionId == auctionId order by bidAmount desc)
    render auctionDetailPage(auction: auction, bids: bids)
}

 
Implementing Bidding Logic
 

• Create a secure route for bidding on auction items.
• Ensure that bid amounts meet the minimum required (currentPrice + bidIncrement) and update records accordingly.
• Broadcast bid updates in real time to all connected users.

// Route to handle bidding on an auction
route "/auction/{auctionId}/bid" {
    // Fetch the auction record and validate status
    auction = db.get(Auction, auctionId)
    if (auction.status != "active") {
        throw "Auction is not active"
    }
    
    // Validate new bid amount; newBid comes from request payload
    if (newBid < auction.currentPrice + auction.bidIncrement) {
        throw "Bid amount too low. Must be at least current price plus bid increment."
    }

    // Record the new bid
    newBidEntry = Bid {
        auctionId: auctionId,
        bidderId: currentUser.id,
        bidAmount: newBid,
        bidTime: now
    }
    db.save(newBidEntry)

    // Update the auction's current price
    auction.currentPrice = newBid
    db.update(auction)

    // Notify all subscribers about the bid update
    realtime.broadcast("auction-update", auction)
}

 
Handling Auction Closure & Payment Processing
 

• Implement a scheduled function to routinely check and close ended auctions.
• Identify the highest bidder upon closing, then process payment from the bidder to the seller using lovable-payment module.
• Notify the involved parties about the auction result.

// Scheduled function to close auctions that have expired
function checkAuctionClosure() {
    expiredAuctions = db.query(Auction where status == "active" and endTime < now)
    for each auction in expiredAuctions {
        auction.status = "closed"
        db.update(auction)

        // Retrieve the winning bid (highest bid)
        winnerBid = db.query(Bid where auctionId == auction.id order by bidAmount desc limit 1)
        if (winnerBid exists) {
            // Process payment from highest bidder to seller
            paymentResult = "lovable-payment".processTransaction(from: winnerBid.bidderId, to: auction.sellerId, amount: auction.currentPrice)
            if (paymentResult.success) {
                // Notify both the winner and seller
                sendEmail(to: db.get(User, winnerBid.bidderId).email, message: "Congratulations! You won the auction for " + auction.title)
                sendEmail(to: db.get(User, auction.sellerId).email, message: "Your item " + auction.title + " has been sold.")
            }
        }
    }
}

// Schedule the closure check every 5 minutes
schedule checkAuctionClosure every "5m"

 
Real-Time Auction Updates
 

• Utilize the lovable-realtime module to subscribe and publish auction events across clients.
• Establish a dedicated route to handle WebSocket connections for live auction updates.

// Route to subscribe to real-time auction updates
route "/auction/subscribe" {
    // Connect the current user to bid update notifications
    realtime.subscribe("auction-update", currentUser.id)
}

 
User Profile & Auction History
 

• Develop a user profile route that displays the user's auction listings and bidding history.
• Provide insights into past auctions for both sellers and bidders.

// Route for displaying user profile with auction activities
route "/user/profile" {
    userAuctions = db.query(Auction where sellerId == currentUser.id)
    userBids = db.query(Bid where bidderId == currentUser.id)
    render profilePage(user: currentUser, auctions: userAuctions, bids: userBids)
}