zeroed-some/localtoast / 0fb258c

-{

-  "name": "backend",

-  "version": "1.0.0",

-  "private": true,

-  "main": "index.js",

-  "scripts": {

-    "dev": "nodemon src/index.js",

-    "start": "node src/index.js",

-    "build": "echo 'No build step for backend'"

-  },

-  "dependencies": {

-    "express": "^4.18.2",

-    "cors": "^2.8.5",

-    "dotenv": "^16.3.1",

-    "sqlite3": "^5.1.6",

-    "axios": "^1.6.2"

-  },

-  "devDependencies": {

-    "nodemon": "^3.0.2"

-  }

-}

-const sqlite3 = require('sqlite3').verbose();

-const path = require('path');

-

-// Database file location

-const DB_PATH = process.env.NODE_ENV === 'production'

-  ? '/data/localtoast.db'  // Railway persistent volume

-  : path.join(__dirname, 'db', 'localtoast.db');

-

-// Create database connection

-const db = new sqlite3.Database(DB_PATH, (err) => {

-  if (err) {

-    console.error('Error opening database:', err);

-  } else {

-    console.log('Connected to SQLite database at:', DB_PATH);

-  }

-});

-

-// Enable foreign keys

-db.run('PRAGMA foreign_keys = ON');

-

-// Initialize database schema

-function initializeDatabase() {

-  return new Promise((resolve, reject) => {

-    db.serialize(() => {

-      // Create restaurants table

-      db.run(`

-        CREATE TABLE IF NOT EXISTS restaurants (

-          id INTEGER PRIMARY KEY AUTOINCREMENT,

-          place_id TEXT UNIQUE NOT NULL,

-          name TEXT NOT NULL,

-          address TEXT NOT NULL,

-          latitude REAL NOT NULL,

-          longitude REAL NOT NULL,

-          created_at DATETIME DEFAULT CURRENT_TIMESTAMP

-        )

-      `, (err) => {

-        if (err) console.error('Error creating restaurants table:', err);

-      });

-

-      // Create ratings table

-      db.run(`

-        CREATE TABLE IF NOT EXISTS ratings (

-          id INTEGER PRIMARY KEY AUTOINCREMENT,

-          restaurant_id INTEGER NOT NULL,

-          rating INTEGER NOT NULL CHECK (rating >= 1 AND rating <= 5),

-          review TEXT,

-          created_at DATETIME DEFAULT CURRENT_TIMESTAMP,

-          FOREIGN KEY (restaurant_id) REFERENCES restaurants (id)

-        )

-      `, (err) => {

-        if (err) console.error('Error creating ratings table:', err);

-      });

-

-      // Create indexes for better performance

-      db.run(`

-        CREATE INDEX IF NOT EXISTS idx_restaurants_location 

-        ON restaurants(latitude, longitude)

-      `);

-

-      db.run(`

-        CREATE INDEX IF NOT EXISTS idx_ratings_restaurant 

-        ON ratings(restaurant_id)

-      `, (err) => {

-        if (err) {

-          reject(err);

-        } else {

-          console.log('Database initialized successfully');

-          resolve();

-        }

-      });

-    });

-  });

-}

-

-// Database helper functions

-const dbHelpers = {

-  // Get all restaurants with ratings

-  getAllRestaurants: () => {

-    return new Promise((resolve, reject) => {

-      const query = `

-        SELECT 

-          r.*,

-          AVG(rt.rating) as average_rating,

-          COUNT(rt.id) as total_ratings

-        FROM restaurants r

-        LEFT JOIN ratings rt ON r.id = rt.restaurant_id

-        GROUP BY r.id

-      `;

-      

-      db.all(query, (err, rows) => {

-        if (err) reject(err);

-        else resolve(rows);

-      });

-    });

-  },

-

-  // Get restaurants within radius

-  getNearbyRestaurants: (lat, lng, radiusKm = 5) => {

-    return new Promise((resolve, reject) => {

-      // SQLite doesn't have built-in geospatial functions, so we'll use a bounding box

-      // This is an approximation but works well for small distances

-      const latDiff = radiusKm / 111; // 1 degree latitude ≈ 111 km

-      const lngDiff = radiusKm / (111 * Math.cos(lat * Math.PI / 180));

-      

-      const query = `

-        SELECT 

-          r.*,

-          AVG(rt.rating) as average_rating,

-          COUNT(rt.id) as total_ratings

-        FROM restaurants r

-        LEFT JOIN ratings rt ON r.id = rt.restaurant_id

-        WHERE 

-          r.latitude BETWEEN ? AND ?

-          AND r.longitude BETWEEN ? AND ?

-        GROUP BY r.id

-      `;

-      

-      db.all(query, [

-        lat - latDiff, lat + latDiff,

-        lng - lngDiff, lng + lngDiff

-      ], (err, rows) => {

-        if (err) reject(err);

-        else resolve(rows);

-      });

-    });

-  },

-

-  // Get restaurant by place_id

-  getRestaurantByPlaceId: (placeId) => {

-    return new Promise((resolve, reject) => {

-      db.get(

-        'SELECT * FROM restaurants WHERE place_id = ?',

-        [placeId],

-        (err, row) => {

-          if (err) reject(err);

-          else resolve(row);

-        }

-      );

-    });

-  },

-

-  // Add new restaurant

-  addRestaurant: (restaurant) => {

-    return new Promise((resolve, reject) => {

-      const { place_id, name, address, latitude, longitude } = restaurant;

-      

-      db.run(

-        `INSERT INTO restaurants (place_id, name, address, latitude, longitude)

-         VALUES (?, ?, ?, ?, ?)`,

-        [place_id, name, address, latitude, longitude],

-        function(err) {

-          if (err) {

-            reject(err);

-          } else {

-            // Get the inserted restaurant

-            db.get(

-              'SELECT * FROM restaurants WHERE id = ?',

-              [this.lastID],

-              (err, row) => {

-                if (err) reject(err);

-                else resolve(row);

-              }

-            );

-          }

-        }

-      );

-    });

-  },

-

-  // Add rating

-  addRating: (restaurantId, rating, review) => {

-    return new Promise((resolve, reject) => {

-      db.run(

-        `INSERT INTO ratings (restaurant_id, rating, review)

-         VALUES (?, ?, ?)`,

-        [restaurantId, rating, review],

-        function(err) {

-          if (err) {

-            reject(err);

-          } else {

-            resolve({ 

-              id: this.lastID, 

-              message: 'Toast rating added successfully! 🍞' 

-            });

-          }

-        }

-      );

-    });

-  },

-

-  // Get ratings for a restaurant

-  getRestaurantRatings: (restaurantId) => {

-    return new Promise((resolve, reject) => {

-      db.all(

-        `SELECT * FROM ratings 

-         WHERE restaurant_id = ? 

-         ORDER BY created_at DESC`,

-        [restaurantId],

-        (err, rows) => {

-          if (err) reject(err);

-          else resolve(rows);

-        }

-      );

-    });

-  },

-

-  // Migrate from JSON files (one-time migration)

-  migrateFromJSON: async () => {

-    const fs = require('fs').promises;

-    const oldRestaurantsPath = path.join(__dirname, 'db', 'restaurants.json');

-    const oldRatingsPath = path.join(__dirname, 'db', 'ratings.json');

-    

-    try {

-      // Check if JSON files exist

-      const restaurantsData = await fs.readFile(oldRestaurantsPath, 'utf8').catch(() => '[]');

-      const ratingsData = await fs.readFile(oldRatingsPath, 'utf8').catch(() => '[]');

-      

-      const restaurants = JSON.parse(restaurantsData);

-      const ratings = JSON.parse(ratingsData);

-      

-      console.log(`Migrating ${restaurants.length} restaurants and ${ratings.length} ratings...`);

-      

-      // Migrate restaurants

-      for (const restaurant of restaurants) {

-        try {

-          await dbHelpers.addRestaurant(restaurant);

-          console.log(`Migrated restaurant: ${restaurant.name}`);

-        } catch (err) {

-          if (err.message.includes('UNIQUE constraint failed')) {

-            console.log(`Restaurant already exists: ${restaurant.name}`);

-          } else {

-            console.error(`Failed to migrate restaurant ${restaurant.name}:`, err);

-          }

-        }

-      }

-      

-      // Migrate ratings

-      for (const rating of ratings) {

-        try {

-          await dbHelpers.addRating(rating.restaurant_id, rating.rating, rating.review);

-          console.log(`Migrated rating for restaurant ${rating.restaurant_id}`);

-        } catch (err) {

-          console.error(`Failed to migrate rating:`, err);

-        }

-      }

-      

-      console.log('Migration completed!');

-      

-      // Rename old files to .backup

-      await fs.rename(oldRestaurantsPath, oldRestaurantsPath + '.backup').catch(() => {});

-      await fs.rename(oldRatingsPath, oldRatingsPath + '.backup').catch(() => {});

-      

-    } catch (error) {

-      console.error('Migration error:', error);

-    }

-  }

-};

-

-module.exports = {

-  db,

-  initializeDatabase,

-  ...dbHelpers

-};

-[

-  {

-    "id": 1,

-    "restaurant_id": 5,

-    "rating": 5,

-    "review": "the toast was beautiful",

-    "created_at": "2025-06-27T16:16:25.712Z"

-  },

-  {

-    "id": 2,

-    "restaurant_id": 8,

-    "rating": 5,

-    "review": "the toast was toasty",

-    "created_at": "2025-06-27T18:06:05.779Z"

-  }

-]

-[

-  {

-    "id": 1,

-    "place_id": "seed_1",

-    "name": "Toast & Jam Café",

-    "address": "100 Breakfast Blvd",

-    "latitude": 38.717600000000004,

-    "longitude": -77.8619,

-    "created_at": "2025-06-27T10:06:45.660Z"

-  },

-  {

-    "id": 2,

-    "place_id": "seed_2",

-    "name": "The Golden Toast",

-    "address": "200 Butter Lane",

-    "latitude": 38.7076,

-    "longitude": -77.8619,

-    "created_at": "2025-06-27T10:06:45.661Z"

-  },

-  {

-    "id": 3,

-    "place_id": "seed_3",

-    "name": "Morning Glory Diner",

-    "address": "300 Sunrise Ave",

-    "latitude": 38.717600000000004,

-    "longitude": -77.8719,

-    "created_at": "2025-06-27T10:06:45.661Z"

-  },

-  {

-    "id": 4,

-    "place_id": "seed_4",

-    "name": "Crispy Corner",

-    "address": "400 Crunch St",

-    "latitude": 38.7076,

-    "longitude": -77.8719,

-    "created_at": "2025-06-27T10:06:45.661Z"

-  },

-  {

-    "id": 5,

-    "place_id": "osm_3071084733",

-    "name": "Don Tequila",

-    "address": "487 East Nelson Street Lexington",

-    "latitude": 37.7786541,

-    "longitude": -79.4380552,

-    "created_at": "2025-06-27T16:15:54.432Z"

-  },

-  {

-    "id": 6,

-    "place_id": "ChIJi39VLne3t4kRECn0u_MdBho",

-    "name": "Toastique",

-    "address": "764 Maine Ave SW, Washington, DC 20024",

-    "latitude": 38.8792519,

-    "longitude": -77.0239086,

-    "created_at": "2025-06-27T16:46:30.252Z"

-  },

-  {

-    "id": 7,

-    "place_id": "ChIJpfRzUMbLTIgR_tCwmLbl8e0",

-    "name": "Seasons' Yield Cafe at Wildberry Market",

-    "address": "9 E Washington St, Lexington, VA 24450",

-    "latitude": 37.7845823,

-    "longitude": -79.44153399999999,

-    "created_at": "2025-06-27T16:55:13.518Z"

-  },

-  {

-    "id": 8,

-    "place_id": "ChIJxwuQAYLLTIgRYpOWdsiLU7k",

-    "name": "Sunrise BBQ",

-    "address": "465 E Nelson St, Lexington, VA 24450",

-    "latitude": 37.7795215,

-    "longitude": -79.4375125,

-    "created_at": "2025-06-27T16:59:49.678Z"

-  }

-]

-// Load environment variables at the very top

-require('dotenv').config();

-

-const express = require('express');

-const cors = require('cors');

-const path = require('path');

-const axios = require('axios');

-

-// Import our new database module

-const { 

-  initializeDatabase, 

-  getAllRestaurants,

-  getNearbyRestaurants,

-  getRestaurantByPlaceId,

-  addRestaurant,

-  addRating,

-  getRestaurantRatings,

-  migrateFromJSON

-} = require('./database');

-

-const app = express();

-const PORT = process.env.PORT || 3000;

-

-// Middleware

-app.use(cors());

-app.use(express.json());

-

-// Test Google Places API

-app.get('/api/test-google', async (req, res) => {

-  if (!process.env.GOOGLE_PLACES_API_KEY) {

-    return res.json({ error: 'Google Places API key not configured' });

-  }

-  

-  try {

-    const response = await axios.get('https://maps.googleapis.com/maps/api/place/textsearch/json', {

-      params: {

-        query: 'french toast restaurant',

-        key: process.env.GOOGLE_PLACES_API_KEY

-      }

-    });

-    

-    res.json({

-      status: 'success',

-      found: response.data.results.length,

-      sample: response.data.results[0]?.name || 'No results'

-    });

-  } catch (error) {

-    res.json({

-      status: 'error',

-      message: error.response?.data?.error_message || error.message

-    });

-  }

-});

-

-// Routes

-app.get('/api/health', (req, res) => {

-  res.json({ status: 'LocalToast is cooking! 🍞' });

-});

-

-// Get nearby restaurants

-app.get('/api/restaurants/nearby', async (req, res) => {

-  try {

-    const { lat, lng, radius = 5 } = req.query;

-    

-    if (!lat || !lng) {

-      return res.status(400).json({ error: 'Latitude and longitude are required' });

-    }

-

-    const restaurants = await getNearbyRestaurants(

-      parseFloat(lat), 

-      parseFloat(lng), 

-      parseFloat(radius)

-    );

-    

-    // If we have no restaurants, try to fetch some from OpenStreetMap

-    if (restaurants.length === 0) {

-      console.log('No restaurants in database, fetching from OpenStreetMap...');

-      

-      const overpassQuery = `

-        [out:json][timeout:25];

-        (

-          node["amenity"="cafe"](around:2000,${lat},${lng});

-          node["shop"="bakery"](around:2000,${lat},${lng});

-          node["amenity"="restaurant"]["cuisine"~"breakfast"](around:2000,${lat},${lng});

-        );

-        out body;

-      `;

-      

-      try {

-        const response = await axios.post(

-          'https://overpass-api.de/api/interpreter',

-          `data=${encodeURIComponent(overpassQuery)}`,

-          { headers: { 'Content-Type': 'application/x-www-form-urlencoded' } }

-        );

-        

-        const places = response.data.elements

-          .filter(place => place.tags && place.tags.name)

-          .slice(0, 5); // Just add first 5 automatically

-        

-        for (const place of places) {

-          try {

-            const newRestaurant = await addRestaurant({

-              place_id: `osm_${place.id}`,

-              name: place.tags.name,

-              address: [

-                place.tags['addr:street'],

-                place.tags['addr:city']

-              ].filter(Boolean).join(', ') || 'Address not available',

-              latitude: place.lat,

-              longitude: place.lon

-            });

-            restaurants.push(newRestaurant);

-          } catch (err) {

-            console.error('Error adding restaurant from OSM:', err);

-          }

-        }

-      } catch (apiError) {

-        console.error('Failed to fetch from OpenStreetMap:', apiError.message);

-      }

-    }

-

-    res.json(restaurants);

-  } catch (error) {

-    console.error('Error fetching restaurants:', error);

-    res.status(500).json({ error: 'Failed to fetch restaurants' });

-  }

-});

-

-// Add a new restaurant

-app.post('/api/restaurants', async (req, res) => {

-  try {

-    const { place_id, name, address, latitude, longitude } = req.body;

-    

-    // Check if restaurant already exists

-    const existing = await getRestaurantByPlaceId(place_id);

-    if (existing) {

-      return res.json(existing);

-    }

-    

-    const newRestaurant = await addRestaurant({

-      place_id,

-      name,

-      address,

-      latitude,

-      longitude

-    });

-    

-    res.json(newRestaurant);

-  } catch (error) {

-    console.error('Error adding restaurant:', error);

-    res.status(500).json({ error: 'Failed to add restaurant' });

-  }

-});

-

-// Add a toast rating

-app.post('/api/restaurants/:id/ratings', async (req, res) => {

-  try {

-    const { id } = req.params;

-    const { rating, review } = req.body;

-    

-    // Simple toast detection

-    if (review && review.length > 0) {

-      const toastKeywords = ['toast', 'bread', 'butter', 'jam', 'marmalade', 'french toast', 'avocado'];

-      const reviewLower = review.toLowerCase();

-      const mentionsToast = toastKeywords.some(keyword => reviewLower.includes(keyword));

-      

-      if (!mentionsToast) {

-        return res.status(400).json({ 

-          error: 'Reviews must be about toast! Please mention the toast in your review.' 

-        });

-      }

-    }

-    

-    const result = await addRating(parseInt(id), rating, review);

-    res.json(result);

-  } catch (error) {

-    console.error('Error adding rating:', error);

-    res.status(500).json({ error: 'Failed to add rating' });

-  }

-});

-

-// Get ratings for a restaurant

-app.get('/api/restaurants/:id/ratings', async (req, res) => {

-  try {

-    const { id } = req.params;

-    const ratings = await getRestaurantRatings(parseInt(id));

-    res.json(ratings);

-  } catch (error) {

-    console.error('Error fetching ratings:', error);

-    res.status(500).json({ error: 'Failed to fetch ratings' });

-  }

-});

-

-// Search for real restaurants using multiple APIs

-app.get('/api/search/places', async (req, res) => {

-  try {

-    const { lat, lng, radius = 1000 } = req.query;

-    

-    console.log('Searching for places at:', { lat, lng, radius });

-    

-    // Try Google Places API first if available

-    if (process.env.GOOGLE_PLACES_API_KEY) {

-      console.log('Using Google Places API...');

-      const textSearchUrl = 'https://maps.googleapis.com/maps/api/place/textsearch/json';

-      

-      try {

-        const response = await axios.get(textSearchUrl, {

-          params: {

-            query: 'french toast OR avocado toast restaurant',

-            location: `${lat},${lng}`,

-            radius: radius,

-            type: 'restaurant|cafe|bakery',

-            key: process.env.GOOGLE_PLACES_API_KEY

-          }

-        });

-        

-        console.log('Google Places response:', response.data.status);

-        

-        if (response.data.results && response.data.results.length > 0) {

-          const places = response.data.results.map(place => ({

-            place_id: place.place_id,

-            name: place.name,

-            address: place.formatted_address || place.vicinity,

-            latitude: place.geometry.location.lat,

-            longitude: place.geometry.location.lng,

-            rating: place.rating || null,

-            price_level: place.price_level || null,

-            category: 'restaurant',

-            source: 'google_places',

-            confidence: place.name.toLowerCase().includes('toast') ? 'high' : 'medium'

-          }));

-          

-          return res.json(places);

-        }

-      } catch (googleError) {

-        console.error('Google Places API error:', googleError.response?.data || googleError.message);

-      }

-    } else {

-      console.log('No Google API key, using OpenStreetMap...');

-    }

-    

-    // Fallback to Overpass API (OpenStreetMap)

-    const overpassQuery = `

-      [out:json][timeout:25];

-      (

-        node["amenity"="restaurant"](around:${radius},${lat},${lng});

-        node["amenity"="cafe"](around:${radius},${lat},${lng});

-        node["shop"="bakery"](around:${radius},${lat},${lng});

-        node["amenity"="fast_food"]["cuisine"~"breakfast"](around:${radius},${lat},${lng});

-      );

-      out body;

-    `;

-    

-    const overpassUrl = 'https://overpass-api.de/api/interpreter';

-    

-    try {

-      console.log('Calling Overpass API...');

-      const response = await axios.post(overpassUrl, `data=${encodeURIComponent(overpassQuery)}`, {

-        headers: { 'Content-Type': 'application/x-www-form-urlencoded' },

-        timeout: 10000 // 10 second timeout

-      });

-      

-      console.log('Overpass response elements:', response.data.elements?.length || 0);

-      

-      const places = response.data.elements

-        .filter(place => place.tags && place.tags.name)

-        .map(place => ({

-          place_id: `osm_${place.id}`,

-          name: place.tags.name,

-          address: [

-            place.tags['addr:housenumber'],

-            place.tags['addr:street'],

-            place.tags['addr:city']

-          ].filter(Boolean).join(' ') || 'Address not available',

-          latitude: place.lat,

-          longitude: place.lon,

-          category: place.tags.amenity || place.tags.shop,

-          cuisine: place.tags.cuisine,

-          opening_hours: place.tags.opening_hours,

-          source: 'openstreetmap',

-          confidence: 'low'

-        }));

-      

-      // Sort by likely to serve toast

-      const sortedPlaces = places.sort((a, b) => {

-        const toastLikely = ['cafe', 'bakery', 'breakfast'];

-        const aScore = toastLikely.some(cat => 

-          a.category?.includes(cat) || a.cuisine?.includes(cat) || a.name.toLowerCase().includes(cat)

-        ) ? 1 : 0;

-        const bScore = toastLikely.some(cat => 

-          b.category?.includes(cat) || b.cuisine?.includes(cat) || b.name.toLowerCase().includes(cat)

-        ) ? 1 : 0;

-        return bScore - aScore;

-      });

-      

-      res.json(sortedPlaces.slice(0, 20));

-    } catch (apiError) {

-      console.error('Overpass API error:', apiError.message);

-      console.error('Error details:', apiError.response?.data || apiError.code);

-      

-      // Return mock data as last resort

-      res.json([

-        {

-          place_id: 'mock_1',

-          name: 'The Breakfast Club',

-          address: '123 Toast Lane',

-          latitude: parseFloat(lat) + 0.01,

-          longitude: parseFloat(lng) + 0.01,

-          category: 'restaurant',

-          source: 'mock',

-          confidence: 'low'

-        }

-      ]);

-    }

-  } catch (error) {

-    console.error('Error searching places:', error);

-    res.status(500).json({ error: 'Failed to search places' });

-  }

-});

-

-// Seed data endpoint

-app.post('/api/seed', async (req, res) => {

-  try {

-    const { lat, lng } = req.body;

-    

-    const seedRestaurants = [

-      { place_id: 'seed_1', name: 'Toast & Jam Café', address: '100 Breakfast Blvd', latitude: parseFloat(lat) + 0.005, longitude: parseFloat(lng) + 0.005 },

-      { place_id: 'seed_2', name: 'The Golden Toast', address: '200 Butter Lane', latitude: parseFloat(lat) - 0.005, longitude: parseFloat(lng) + 0.005 },

-      { place_id: 'seed_3', name: 'Morning Glory Diner', address: '300 Sunrise Ave', latitude: parseFloat(lat) + 0.005, longitude: parseFloat(lng) - 0.005 },

-      { place_id: 'seed_4', name: 'Crispy Corner', address: '400 Crunch St', latitude: parseFloat(lat) - 0.005, longitude: parseFloat(lng) - 0.005 }

-    ];

-    

-    let added = 0;

-    

-    for (const seedRestaurant of seedRestaurants) {

-      try {

-        await addRestaurant(seedRestaurant);

-        added++;

-      } catch (err) {

-        if (err.message.includes('UNIQUE constraint failed')) {

-          console.log(`Seed restaurant already exists: ${seedRestaurant.name}`);

-        } else {

-          console.error(`Failed to add seed restaurant:`, err);

-        }

-      }

-    }

-    

-    res.json({ message: `Seeded ${added} restaurants with toast! 🍞` });

-  } catch (error) {

-    console.error('Error seeding data:', error);

-    res.status(500).json({ error: 'Failed to seed data' });

-  }

-});

-

-// Migration endpoint (one-time use)

-app.post('/api/migrate', async (req, res) => {

-  try {

-    await migrateFromJSON();

-    res.json({ message: 'Migration completed successfully!' });

-  } catch (error) {

-    console.error('Migration error:', error);

-    res.status(500).json({ error: 'Migration failed' });

-  }

-});

-

-// Initialize database and start server

-initializeDatabase()

-  .then(() => {

-    app.listen(PORT, () => {

-      console.log(`LocalToast backend running on http://localhost:${PORT} 🍞`);

-      console.log('Database: SQLite');

-      

-      // Offer to migrate on first run

-      console.log('\nIf you have existing JSON data, run:');

-      console.log(`curl -X POST http://localhost:${PORT}/api/migrate`);

-    });

-  })

-  .catch(err => {

-    console.error('Failed to initialize database:', err);

-    process.exit(1);

-  });

-# See https://help.github.com/articles/ignoring-files/ for more about ignoring files.

-

-# dependencies

-/node_modules

-/.pnp

-.pnp.*

-.yarn/*

-!.yarn/patches

-!.yarn/plugins

-!.yarn/releases

-!.yarn/versions

-

-# testing

-/coverage

-

-# next.js

-/.next/

-/out/

-

-# production

-/build

-

-# misc

-.DS_Store

-*.pem

-

-# debug

-npm-debug.log*

-yarn-debug.log*

-yarn-error.log*

-.pnpm-debug.log*

-

-# env files (can opt-in for committing if needed)

-.env*

-

-# vercel

-.vercel

-

-# typescript

-*.tsbuildinfo

-next-env.d.ts

-# frontend/.npmrc

-legacy-peer-deps=true

-This is a [Next.js](https://nextjs.org) project bootstrapped with [`create-next-app`](https://nextjs.org/docs/app/api-reference/cli/create-next-app).

-

-## Getting Started

-

-First, run the development server:

-

-```bash

-npm run dev

-# or

-yarn dev

-# or

-pnpm dev

-# or

-bun dev

-```

-

-Open [http://localhost:3000](http://localhost:3000) with your browser to see the result.

-

-You can start editing the page by modifying `app/page.tsx`. The page auto-updates as you edit the file.

-

-This project uses [`next/font`](https://nextjs.org/docs/app/building-your-application/optimizing/fonts) to automatically optimize and load [Geist](https://vercel.com/font), a new font family for Vercel.

-

-## Learn More

-

-To learn more about Next.js, take a look at the following resources:

-

-- [Next.js Documentation](https://nextjs.org/docs) - learn about Next.js features and API.

-- [Learn Next.js](https://nextjs.org/learn) - an interactive Next.js tutorial.

-

-You can check out [the Next.js GitHub repository](https://github.com/vercel/next.js) - your feedback and contributions are welcome!

-

-## Deploy on Vercel

-

-The easiest way to deploy your Next.js app is to use the [Vercel Platform](https://vercel.com/new?utm_medium=default-template&filter=next.js&utm_source=create-next-app&utm_campaign=create-next-app-readme) from the creators of Next.js.

-

-Check out our [Next.js deployment documentation](https://nextjs.org/docs/app/building-your-application/deploying) for more details.

-@import "tailwindcss";

-@tailwind base;

-@tailwind components;

-@tailwind utilities;

-

-:root {

-  --background: #ffffff;

-  --foreground: #171717;

-}

-

-@theme inline {

-  --color-background: var(--background);

-  --color-foreground: var(--foreground);

-  --font-sans: var(--font-geist-sans);

-  --font-mono: var(--font-geist-mono);

-}

-

-@media (prefers-color-scheme: dark) {

-  :root {

-    --background: #0a0a0a;

-    --foreground: #ededed;

-  }

-}

-

-body {

-  background: var(--background);

-  color: var(--foreground);

-  font-family: Arial, Helvetica, sans-serif;

-}

-

-html, body {

-  height: 100%;

-  margin: 0;

-  padding: 0;

-}

-

-/* Fix for Leaflet map tiles */

-.leaflet-container {

-  height: 100%;

-  width: 100%;

-  position: relative;

-}

-

-.leaflet-tile-pane {

-  z-index: 1;

-}

-

-.leaflet-overlay-pane {

-  z-index: 2;

-}

-

-/* Fix tile loading issues */

-.leaflet-tile {

-  max-width: none !important;

-  max-height: none !important;

-}

-

-/* Fix control positioning */

-.leaflet-control-container {

-  position: absolute;

-  z-index: 1000;

-}

-

-/* Ensure proper stacking */

-.leaflet-pane {

-  position: absolute;

-  z-index: 400;

-}

-

-.leaflet-map-pane {

-  position: absolute;

-  left: 0;

-  top: 0;

-}

-

-/* Fix marker positioning */

-.leaflet-marker-pane {

-  z-index: 600;

-}

-

-.leaflet-popup-pane {

-  z-index: 700;

-}

-import type { Metadata } from "next";

-import { Geist, Geist_Mono } from "next/font/google";

-import "./globals.css";

-

-const geistSans = Geist({

-  variable: "--font-geist-sans",

-  subsets: ["latin"],

-});

-

-const geistMono = Geist_Mono({

-  variable: "--font-geist-mono",

-  subsets: ["latin"],

-});

-

-export const metadata: Metadata = {

-  title: "Create Next App",

-  description: "Generated by create next app",

-};

-

-export default function RootLayout({

-  children,

-}: Readonly<{

-  children: React.ReactNode;

-}>) {

-  return (

-    <html lang="en">

-      <body

-        className={`${geistSans.variable} ${geistMono.variable} antialiased`}

-      >

-        {children}

-      </body>

-    </html>

-  );

-}

-'use client';

-

-import { useState, useEffect } from 'react';

-import dynamic from 'next/dynamic';

-import { MapPin, Star, Plus, Loader2 } from 'lucide-react';

-import { QueryClient, QueryClientProvider, useQuery, useMutation } from '@tanstack/react-query';

-import axios from 'axios';

-

-// Dynamic import for Leaflet to avoid SSR issues

-const Map = dynamic(() => import('@/components/Map'), {

-  ssr: false,

-  loading: () => <div className="h-full w-full bg-gray-100 animate-pulse" />

-});

-

-const queryClient = new QueryClient();

-const API_URL = process.env.NEXT_PUBLIC_API_URL || 'http://localhost:3000';

-

-interface Restaurant {

-  id: number;

-  place_id: string;

-  name: string;

-  address: string;

-  latitude: number;

-  longitude: number;

-  average_rating: number | null;

-  total_ratings: number;

-}

-

-interface UserLocation {

-  lat: number;

-  lng: number;

-}

-

-function HomePage() {

-  const [userLocation, setUserLocation] = useState<UserLocation | null>(null);

-  const [selectedRestaurant, setSelectedRestaurant] = useState<Restaurant | null>(null);

-  const [showAddRating, setShowAddRating] = useState(false);

-  const [rating, setRating] = useState(5);

-  const [review, setReview] = useState('');

-  const [showSearch, setShowSearch] = useState(false);

-  const [searchResults, setSearchResults] = useState<any[]>([]);

-  const [isSearching, setIsSearching] = useState(false);

-  const [addingPlaceId, setAddingPlaceId] = useState<string | null>(null);

-

-  // Get user's location

-  useEffect(() => {

-    if (navigator.geolocation) {

-      navigator.geolocation.getCurrentPosition(

-        (position) => {

-          setUserLocation({

-            lat: position.coords.latitude,

-            lng: position.coords.longitude

-          });

-        },

-        (error) => {

-          console.error('Error getting location:', error.message || 'Location access denied');

-          // Default to a location (NYC)

-          setUserLocation({ lat: 40.7128, lng: -74.0060 });

-        }

-      );

-    }

-  }, []);

-

-  // Fetch nearby restaurants

-  const { data: restaurants, isLoading, refetch } = useQuery({

-    queryKey: ['restaurants', userLocation],

-    queryFn: async () => {

-      if (!userLocation) return [];

-      const response = await axios.get(`${API_URL}/api/restaurants/nearby`, {

-        params: {

-          lat: userLocation.lat,

-          lng: userLocation.lng

-        }

-      });

-      return response.data;

-    },

-    enabled: !!userLocation

-  });

-

-  // Add rating mutation

-  const addRatingMutation = useMutation({

-    mutationFn: async ({ restaurantId, rating, review }: { restaurantId: number, rating: number, review: string }) => {

-      const response = await axios.post(`${API_URL}/api/restaurants/${restaurantId}/ratings`, {

-        rating,

-        review

-      });

-      return response.data;

-    },

-    onSuccess: () => {

-      refetch();

-      setShowAddRating(false);

-      setRating(5);

-      setReview('');

-      alert('Toast rating added! 🍞');

-    },

-    onError: (error: any) => {

-      alert(error.response?.data?.error || 'Failed to add rating');

-    }

-  });

-

-  // Handle rating from map popup

-  const handleMapRating = async (restaurantId: number, rating: number, review: string) => {

-    try {

-      await axios.post(`${API_URL}/api/restaurants/${restaurantId}/ratings`, {

-        rating,

-        review

-      });

-      

-      // Refresh the restaurants list to update ratings

-      await refetch();

-      

-      // Close any open panels

-      setSelectedRestaurant(null);

-      

-      // Show success (could use a toast notification library here)

-      console.log('Toast rating added! 🍞');

-    } catch (error: any) {

-      alert(error.response?.data?.error || 'Failed to add rating');

-      throw error; // Re-throw so popup knows it failed

-    }

-  };

-

-  // Search for nearby places

-  const searchNearbyPlaces = async () => {

-    if (!userLocation) return;

-    

-    setIsSearching(true);

-    try {

-      const response = await axios.get(`${API_URL}/api/search/places`, {

-        params: {

-          lat: userLocation.lat,

-          lng: userLocation.lng,

-          radius: 2000 // 2km radius

-        }

-      });

-      

-      // Calculate distances and sort by closest

-      const placesWithDistance = response.data.map((place: any) => {

-        const distance = calculateDistance(

-          userLocation.lat,

-          userLocation.lng,

-          place.latitude,

-          place.longitude

-        );

-        return { ...place, distance };

-      });

-      

-      // Sort by distance (closest first)

-      placesWithDistance.sort((a: any, b: any) => a.distance - b.distance);

-      

-      setSearchResults(placesWithDistance);

-      setShowSearch(true);

-    } catch (error) {

-      console.error('Error searching places:', error);

-      alert('Failed to search for nearby places');

-    } finally {

-      setIsSearching(false);

-    }

-  };

-

-  // Calculate distance between two points in kilometers

-  const calculateDistance = (lat1: number, lon1: number, lat2: number, lon2: number) => {

-    const R = 6371; // Radius of the Earth in km

-    const dLat = (lat2 - lat1) * Math.PI / 180;

-    const dLon = (lon2 - lon1) * Math.PI / 180;

-    const a = 

-      Math.sin(dLat/2) * Math.sin(dLat/2) +

-      Math.cos(lat1 * Math.PI / 180) * Math.cos(lat2 * Math.PI / 180) *

-      Math.sin(dLon/2) * Math.sin(dLon/2);

-    const c = 2 * Math.atan2(Math.sqrt(a), Math.sqrt(1-a));

-    return R * c;

-  };

-

-  // Add a place from search results

-  const addPlace = async (place: any) => {

-    setAddingPlaceId(place.place_id);

-    try {

-      const response = await axios.post(`${API_URL}/api/restaurants`, {

-        place_id: place.place_id,

-        name: place.name,

-        address: place.address,

-        latitude: place.latitude,

-        longitude: place.longitude

-      });

-      

-      // Refresh the restaurants list

-      await refetch();

-      

-      // Remove the added place from search results

-      setSearchResults(prev => prev.filter(p => p.place_id !== place.place_id));

-      

-      // If no more results, close the panel

-      if (searchResults.length <= 1) {

-        setShowSearch(false);

-      }

-    } catch (error) {

-      console.error('Error adding place:', error);

-      alert('Failed to add place');

-    } finally {

-      setAddingPlaceId(null);

-    }

-  };

-

-  return (

-    <div className="h-screen flex flex-col">

-      {/* Header */}

-      <header className="bg-amber-600 text-white p-4 shadow-lg">

-        <div className="max-w-7xl mx-auto flex items-center justify-between">

-          <div className="flex items-center space-x-2">

-            <span className="text-2xl">🍞</span>

-            <h1 className="text-2xl font-bold">LocalToast</h1>

-          </div>

-          <div className="flex items-center space-x-4">

-            <p className="text-sm hidden sm:block">Find and rate the best toast in town!</p>

-            <button

-              onClick={searchNearbyPlaces}

-              disabled={!userLocation || isSearching}

-              className="bg-amber-700 hover:bg-amber-800 px-4 py-2 rounded-lg text-sm font-medium transition disabled:opacity-50 flex items-center space-x-2"

-            >

-              {isSearching ? (

-                <Loader2 className="w-4 h-4 animate-spin" />

-              ) : (

-                <Plus className="w-4 h-4" />

-              )}

-              <span>find toast</span>

-            </button>

-          </div>

-        </div>

-      </header>

-

-      {/* Main Content */}

-      <div className="flex-1 relative">

-        {userLocation ? (

-          <>

-            <Map

-              center={userLocation}

-              restaurants={restaurants || []}

-              searchResults={showSearch ? searchResults : []}

-              onRestaurantClick={setSelectedRestaurant}

-              onAddPlace={addPlace}

-              onRateRestaurant={handleMapRating}

-            />

-            

-            {/* Restaurant Details Panel */}

-            {selectedRestaurant && !showSearch && (

-              <div className="absolute bottom-0 left-0 right-0 bg-white p-6 shadow-xl rounded-t-xl max-h-96 overflow-y-auto z-[1000]">

-                <div className="flex justify-between items-start mb-4">

-                  <div>

-                    <h2 className="text-xl font-bold text-gray-900">{selectedRestaurant.name}</h2>

-                    <p className="text-gray-700">{selectedRestaurant.address}</p>

-                  </div>

-                  <button

-                    onClick={() => setSelectedRestaurant(null)}

-                    className="text-gray-700 hover:text-gray-900"

-                  >

-                    ✕

-                  </button>

-                </div>

-                

-                <div className="flex items-center space-x-4 mb-4">

-                  <div className="flex items-center">

-                    {selectedRestaurant.average_rating ? (

-                      <>

-                        <Star className="w-5 h-5 text-yellow-500 fill-current" />

-                        <span className="ml-1 font-semibold text-gray-900">

-                          {selectedRestaurant.average_rating.toFixed(1)}

-                        </span>

-                      </>

-                    ) : (

-                      <span className="text-gray-700">No ratings yet</span>

-                    )}

-                  </div>

-                  <span className="text-gray-700">

-                    {selectedRestaurant.total_ratings} {selectedRestaurant.total_ratings === 1 ? 'rating' : 'ratings'}

-                  </span>

-                </div>

-

-                {!showAddRating ? (

-                  <button

-                    onClick={() => setShowAddRating(true)}

-                    className="w-full bg-amber-600 text-white py-2 px-4 rounded-lg hover:bg-amber-700 transition"

-                  >

-                    Rate the Toast! 🍞

-                  </button>

-                ) : (

-                  <div className="space-y-4">

-                    <div>

-                      <label className="block text-sm font-medium mb-2">Rating</label>

-                      <div className="flex space-x-2">

-                        {[1, 2, 3, 4, 5].map((value) => (

-                          <button

-                            key={value}

-                            onClick={() => setRating(value)}

-                            className={`p-2 ${rating >= value ? 'text-yellow-500' : 'text-gray-300'}`}

-                          >

-                            <Star className="w-8 h-8 fill-current" />

-                          </button>

-                        ))}

-                      </div>

-                    </div>

-                    

-                    <div>

-                      <label className="block text-sm font-medium mb-2">

-                        Review (must be about toast!)

-                      </label>

-                      <textarea

-                        value={review}

-                        onChange={(e) => setReview(e.target.value)}

-                        className="w-full p-2 border rounded-lg"

-                        rows={3}

-                        placeholder="How was the toast? Crispy? Buttery? Perfect golden brown?"

-                      />

-                    </div>

-                    

-                    <div className="flex space-x-2">

-                      <button

-                        onClick={handleAddRating}

-                        disabled={addRatingMutation.isPending}

-                        className="flex-1 bg-amber-600 text-white py-2 px-4 rounded-lg hover:bg-amber-700 transition disabled:opacity-50"

-                      >

-                        {addRatingMutation.isPending ? 'Submitting...' : 'Submit Rating'}

-                      </button>

-                      <button

-                        onClick={() => {

-                          setShowAddRating(false);

-                          setRating(5);

-                          setReview('');

-                        }}

-                        className="flex-1 bg-gray-200 text-gray-700 py-2 px-4 rounded-lg hover:bg-gray-300 transition"

-                      >

-                        Cancel

-                      </button>

-                    </div>

-                  </div>

-                )}

-              </div>

-            )}

-

-            {/* Search Results Panel */}

-            {showSearch && (

-              <div className="absolute bottom-0 left-0 right-0 bg-white p-6 shadow-xl rounded-t-xl max-h-96 overflow-y-auto z-[1000]">

-                <div className="flex justify-between items-center mb-4">

-                  <h2 className="text-2xl font-bold text-black">Nearby Places That Might Serve Toast 🍞</h2>

-                  <button

-                    onClick={() => setShowSearch(false)}

-                    className="text-black hover:bg-gray-100 p-2 rounded-lg transition"

-                    aria-label="Close search results"

-                  >

-                    ✕

-                  </button>

-                </div>

-                

-                <p className="text-base font-semibold text-black mb-4">

-                  Found {searchResults.length} places nearby. Cafes, bakeries, and breakfast spots are shown first!

-                </p>

-                

-                {searchResults.length === 0 ? (

-                  <p className="text-center text-black font-medium py-8">

-                    No places found nearby. Try moving the map to a different area.

-                  </p>

-                ) : (

-                  <div className="space-y-3">

-                    {searchResults.map((place) => (

-                      <div key={place.place_id} className="border-2 border-gray-300 rounded-lg p-4 hover:bg-amber-50 transition-colors">

-                        <div className="flex justify-between items-start gap-4">

-                          <div className="flex-1">

-                            <h3 className="text-lg font-black text-black">{place.name}</h3>

-                            <p className="text-base font-normal text-black mt-1">{place.address}</p>

-                            <div className="flex flex-wrap items-center gap-2 mt-2">

-                              <span className="text-sm font-bold text-black uppercase bg-gray-100 px-2 py-1 rounded">

-                                {place.category}

-                              </span>

-                              {place.cuisine && (

-                                <span className="text-sm font-bold text-black bg-gray-100 px-2 py-1 rounded">

-                                  {place.cuisine}

-                                </span>

-                              )}

-                              {place.distance && (

-                                <span className="text-sm font-black text-black bg-amber-100 px-2 py-1 rounded">

-                                  📍 {place.distance < 1 

-                                    ? `${Math.round(place.distance * 1000)}m`

-                                    : `${place.distance.toFixed(1)}km`

-                                  }

-                                </span>

-                              )}

-                            </div>

-                            {place.confidence && (

-                              <span className={`inline-block mt-2 px-3 py-1.5 rounded text-sm font-black ${

-                                place.confidence === 'high' ? 'bg-green-600 text-white' :

-                                place.confidence === 'medium' ? 'bg-yellow-500 text-black' :

-                                'bg-gray-600 text-white'

-                              }`}>

-                                {place.confidence === 'high' ? '🍞 LIKELY HAS TOAST!' :

-                                 place.confidence === 'medium' ? '🤔 MIGHT HAVE TOAST' :

-                                 '❓ CHECK MENU'}

-                              </span>

-                            )}

-                          </div>

-                          <button

-                            onClick={() => addPlace(place)}

-                            disabled={addingPlaceId === place.place_id}

-                            className={`${

-                              addingPlaceId === place.place_id 

-                                ? 'bg-green-600 text-white' 

-                                : 'bg-black hover:bg-gray-800 text-white'

-                            } px-5 py-2.5 rounded-md text-base font-bold transition shadow-md hover:shadow-lg min-w-[80px] disabled:cursor-not-allowed`}

-                            aria-label={`Add ${place.name} to LocalToast`}

-                          >

-                            {addingPlaceId === place.place_id ? '✓' : 'Add'}

-                          </button>

-                        </div>

-                      </div>

-                    ))}

-                  </div>

-                )}

-              </div>

-            )}

-          </>

-        ) : (

-          <div className="flex items-center justify-center h-full">

-            <div className="text-center">

-              <Loader2 className="w-8 h-8 animate-spin mx-auto mb-4 text-amber-600" />

-              <p>Getting your location...</p>

-            </div>

-          </div>

-        )}

-      </div>

-    </div>

-  );

-}

-

-export default function Page() {

-  return (

-    <QueryClientProvider client={queryClient}>

-      <HomePage />

-    </QueryClientProvider>

-  );

-}

-'use client';

-

-import { useEffect, useState } from 'react';

-import L from 'leaflet';

-import { MapContainer, TileLayer, Marker, Popup, useMap } from 'react-leaflet';

-import 'leaflet/dist/leaflet.css';

-import { Star } from 'lucide-react';

-

-// Fix for default markers in React-Leaflet

-delete (L.Icon.Default.prototype as any)._getIconUrl;

-L.Icon.Default.mergeOptions({

-  iconRetinaUrl: '/leaflet/marker-icon-2x.png',

-  iconUrl: '/leaflet/marker-icon.png',

-  shadowUrl: '/leaflet/marker-shadow.png',

-});

-

-interface Restaurant {

-  id: number;

-  place_id: string;

-  name: string;

-  address: string;

-  latitude: number;

-  longitude: number;

-  average_rating: number | null;

-  total_ratings: number;

-}

-

-interface MapProps {

-  center: { lat: number; lng: number };

-  restaurants: Restaurant[];

-  searchResults?: any[];

-  onRestaurantClick: (restaurant: Restaurant) => void;

-  onAddPlace?: (place: any) => void;

-  onRateRestaurant?: (restaurantId: number, rating: number, review: string) => void;

-}

-

-// Component to recenter map when location changes

-function RecenterMap({ center }: { center: { lat: number; lng: number } }) {

-  const map = useMap();

-  

-  useEffect(() => {

-    map.setView([center.lat, center.lng], 13);

-  }, [center, map]);

-  

-  return null;

-}

-

-// Custom toast icon - using URL encoding to handle emoji

-const toastIcon = new L.Icon({

-  iconUrl: 'data:image/svg+xml,' + encodeURIComponent(`

-    <svg width="40" height="40" viewBox="0 0 40 40" xmlns="http://www.w3.org/2000/svg">

-      <circle cx="20" cy="20" r="18" fill="#F59E0B" stroke="#92400E" stroke-width="2"/>

-      <text x="20" y="27" text-anchor="middle" font-size="24">🍞</text>

-    </svg>

-  `),

-  iconSize: [40, 40],

-  iconAnchor: [20, 40],

-  popupAnchor: [0, -40],

-});

-

-// User location icon

-const userIcon = new L.Icon({

-  iconUrl: 'data:image/svg+xml,' + encodeURIComponent(`

-    <svg width="30" height="30" viewBox="0 0 30 30" xmlns="http://www.w3.org/2000/svg">

-      <circle cx="15" cy="15" r="10" fill="#3B82F6" stroke="#1E40AF" stroke-width="2"/>

-      <circle cx="15" cy="15" r="4" fill="white"/>

-    </svg>

-  `),

-  iconSize: [30, 30],

-  iconAnchor: [15, 15],

-});

-

-// Search result icon (gray/tentative)

-const searchResultIcon = new L.Icon({

-  iconUrl: 'data:image/svg+xml,' + encodeURIComponent(`

-    <svg width="40" height="40" viewBox="0 0 40 40" xmlns="http://www.w3.org/2000/svg">

-      <circle cx="20" cy="20" r="18" fill="#9CA3AF" stroke="#4B5563" stroke-width="2" stroke-dasharray="5,5"/>

-      <text x="20" y="27" text-anchor="middle" font-size="20">❓</text>

-    </svg>

-  `),

-  iconSize: [40, 40],

-  iconAnchor: [20, 40],

-  popupAnchor: [0, -40],

-});

-

-// Restaurant popup with rating functionality

-function RestaurantPopup({ restaurant, onRate }: { restaurant: Restaurant; onRate?: (id: number, rating: number, review: string) => void }) {

-  const [showRating, setShowRating] = useState(false);

-  const [rating, setRating] = useState(5);

-  const [review, setReview] = useState('');

-  const [isSubmitting, setIsSubmitting] = useState(false);

-

-  const handleSubmit = async () => {

-    console.log('Submitting rating:', { restaurantId: restaurant.id, rating, review });

-    if (!onRate || !review.trim()) {

-      console.log('Cannot submit: onRate missing or no review');

-      return;

-    }

-    

-    setIsSubmitting(true);

-    try {

-      await onRate(restaurant.id, rating, review);

-      setShowRating(false);

-      setRating(5);

-      setReview('');

-    } catch (error) {

-      console.error('Rating submission error:', error);

-    } finally {

-      setIsSubmitting(false);

-    }

-  };

-

-  return (

-    <div className="p-3 min-w-[250px]">

-      <h3 className="font-bold text-base mb-1">{restaurant.name}</h3>

-      <p className="text-sm text-gray-700 mb-2">{restaurant.address}</p>

-      

-      {restaurant.average_rating ? (

-        <p className="text-sm font-semibold mb-3 flex items-center">

-          <Star className="w-4 h-4 text-yellow-500 fill-current mr-1" />

-          {restaurant.average_rating.toFixed(1)} ({restaurant.total_ratings} {restaurant.total_ratings === 1 ? 'rating' : 'ratings'})

-        </p>

-      ) : (

-        <p className="text-sm text-gray-600 mb-3">No ratings yet</p>

-      )}

-      

-      {!showRating ? (

-        <button

-          onClick={() => setShowRating(true)}