Lovable Prompts for Building Classifieds

 
Setting Up Project Files & Dependencies
 

• Create your main application file named classifieds.lov to host all routes and core logic.
• Add dependency installation directly in your code since Lovable.dev does not have a terminal. Include required modules:

// Import necessary modules for Classifieds functionality

import "lovable-db"         // For database operations and persistent storage
import "lovable-auth"       // For user authentication and session management
import "lovable-files"      // For handling images and file uploads

• Ensure that these dependencies are configured appropriately in your project settings.

 
Defining Data Models
 

• Define models for Users, Categories, and Listings with clear field validations and relationships.
• Model for Listings should include title, description, price, category, images, and user reference.

// Define User model
model User {
  id        : UUID          // Unique user identifier
  username  : String        // Username for login
  password  : String        // Encrypted password
  email     : String        // User email address
  createdAt : DateTime      // Registration date
}

// Define Category model for listings classification
model Category {
  id          : UUID        // Unique category identifier
  name        : String      // Category name (e.g., Vehicles, Electronics)
  description : String      // Short description of category
}

// Define Listing model for classified ads
model Listing {
  id          : UUID        // Listing unique identifier
  title       : String      // Title of the ad
  description : String      // Detailed description
  price       : Decimal     // Price value
  images      : Array       // Array of image file paths
  categoryId  : UUID        // Reference to Category model
  userId      : UUID        // Reference to User model for ownership
  createdAt   : DateTime    // Posting date and time
}

 
Setting Up Routes & Application Logic
 

• Create routes for user authentication, listing creation, listing management, search, and filtering.
• Implement middleware to protect routes that require authentication.

// Route: User registration and login
route "/auth/register" {
  method: POST,
  action: function(request, response) {
    // Validate input, create a new user, and respond with session token
    // Use lovable-auth for creating secure sessions
  }
}

route "/auth/login" {
  method: POST,
  action: function(request, response) {
    // Validate credentials and issue a session token using lovable-auth
  }
}

// Route: Create a new Listing (authenticated)
route "/listing/create" {
  method: POST,
  middleware: ["isAuthenticated"], // Middleware provided by lovable-auth
  action: function(request, response) {
    // Validate listing data and store in the database via lovable-db
    // Handle image upload using lovable-files module
  }
}

// Route: Retrieve Listings with search and filter options
route "/listing/search" {
  method: GET,
  action: function(request, response) {
    // Accept query parameters like category, price range, keywords
    // Query the listings from lovable-db and return results
  }
}

// Route: Manage Listing (view, update, delete)
route "/listing/manage" {
  method: POST,
  middleware: ["isAuthenticated"],
  action: function(request, response) {
    // Allow users to update or delete their own listings
    // Verify listing ownership before processing actions
  }
}

 
Implementing Business Logic & User Flow
 

• Ensure that when a user posts a listing, validations for required fields and data formats are enforced.
• Implement a clear user flow: registration, authentication, creation of listing, image upload, and listing management.
• Utilize lovable-db for CRUD operations, ensuring proper error handling and feedback in each step.
• Design the search mechanism to support filtering by category, price range, and keyword matching.
• Leverage middleware for secure login sessions and restrict operations on listings to their respective owners.

 
Final Integration & Testing
 

• Review all routes and test each user flow scenario like user registration, login, posting, and searching for a listing.
• Include inline comments and ensure the code is structured for readability and easy modifications.
• Perform end-to-end validations using test listings and dummy user data to guarantee a seamless experience.

// Example function to handle image uploads during listing creation
function processImages(imageData) {
  // Use lovable-files to process and store image files
  // Return array of stored image file paths
}

// Example of route usage for updating a listing
route "/listing/update" {
  method: POST,
  middleware: ["isAuthenticated"],
  action: function(request, response) {
    // Validate request: ensure user owns the listing
    // Update listing data in lovable-db and handle new image uploads if any
  }
}