`4f598fd`

migrate to sqlite

Authored by

espadonne 10 months ago

SHA: 4f598fd007097b135adeb1c20aafb50fa0d61481
Parents: 28cf243
Tree: cff4bd6

3 changed files

Status	File	+	-
A	`backend/src/database.js`	263	0
A	`backend/src/db/localtoast.db`	bin
M	`backend/src/index.js`	78	144

backend/src/database.jsadded

++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
++};

backend/src/db/localtoast.dbadded

Binary file changed.

backend/src/index.jsmodified

  const express = require('express');
  const cors = require('cors');
--const fs = require('fs').promises;
  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;
  app.use(cors());
  app.use(express.json());
--// Simple file-based storage
--const DATA_DIR = path.join(__dirname, 'db');
--const RESTAURANTS_FILE = path.join(DATA_DIR, 'restaurants.json');
--const RATINGS_FILE = path.join(DATA_DIR, 'ratings.json');
--
--// Initialize data files
--async function initializeData() {
--  try {
--    await fs.mkdir(DATA_DIR, { recursive: true });
--
--    try {
--      await fs.access(RESTAURANTS_FILE);
--    } catch {
--      await fs.writeFile(RESTAURANTS_FILE, JSON.stringify([]));
--    }
--
--    try {
--      await fs.access(RATINGS_FILE);
--    } catch {
--      await fs.writeFile(RATINGS_FILE, JSON.stringify([]));
--    }
--  } catch (error) {
--    console.error('Error initializing data files:', error);
--  }
--}
--
--// Helper functions
--async function getRestaurants() {
--  const data = await fs.readFile(RESTAURANTS_FILE, 'utf8');
--  return JSON.parse(data);
--}
--
--async function saveRestaurants(restaurants) {
--  await fs.writeFile(RESTAURANTS_FILE, JSON.stringify(restaurants, null, 2));
--}
--
--async function getRatings() {
--  const data = await fs.readFile(RATINGS_FILE, 'utf8');
--  return JSON.parse(data);
--}
--
--async function saveRatings(ratings) {
--  await fs.writeFile(RATINGS_FILE, JSON.stringify(ratings, null, 2));
--}
--
--// Calculate distance between two coordinates (in km)
--function calculateDistance(lat1, lon1, lat2, lon2) {
--  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;
--}
--
  // Test Google Places API
  app.get('/api/test-google', async (req, res) => {
    if (!process.env.GOOGLE_PLACES_API_KEY) {
        return res.status(400).json({ error: 'Latitude and longitude are required' });
+     }
--    const restaurants = await getRestaurants();
++    const restaurants = await getNearbyRestaurants(
--    const ratings = await getRatings();
++      parseFloat(lat),
++      parseFloat(lng),
++      parseFloat(radius)
++    );
      // If we have no restaurants, try to fetch some from OpenStreetMap
      if (restaurants.length === 0) {
          const places = response.data.elements
            .filter(place => place.tags && place.tags.name)
--          .slice(0, 5) // Just add first 5 automatically
++          .slice(0, 5); // Just add first 5 automatically
--          .map((place, index) => ({
--            id: index + 1,
--            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,
--            created_at: new Date().toISOString()
--          }));
--        if (places.length > 0) {
++        for (const place of places) {
--          await saveRestaurants(places);
++          try {
--          restaurants.push(...places);
++            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);
+       }
+     }
--
--    // Filter restaurants within radius and calculate ratings
--    const nearbyRestaurants = restaurants
--      .filter(r => calculateDistance(parseFloat(lat), parseFloat(lng), r.latitude, r.longitude) <= radius)
--      .map(restaurant => {
--        const restaurantRatings = ratings.filter(r => r.restaurant_id === restaurant.id);
--        const average_rating = restaurantRatings.length > 0
--          ? restaurantRatings.reduce((sum, r) => sum + r.rating, 0) / restaurantRatings.length
--          : null;
--
--        return {
--          ...restaurant,
--          average_rating,
--          total_ratings: restaurantRatings.length
--        };
--      });
--    res.json(nearbyRestaurants);
++    res.json(restaurants);
    } catch (error) {
      console.error('Error fetching restaurants:', error);
      res.status(500).json({ error: 'Failed to fetch restaurants' });
    try {
      const { place_id, name, address, latitude, longitude } = req.body;
--    const restaurants = await getRestaurants();
--
      // Check if restaurant already exists
--    const existing = restaurants.find(r => r.place_id === place_id);
++    const existing = await getRestaurantByPlaceId(place_id);
      if (existing) {
        return res.json(existing);
+     }
--    const newRestaurant = {
++    const newRestaurant = await addRestaurant({
--      id: restaurants.length + 1,
        place_id,
        name,
        address,
        latitude,
--      longitude,
++      longitude
--      created_at: new Date().toISOString()
++    });
--    };
--
--    restaurants.push(newRestaurant);
--    await saveRestaurants(restaurants);
      res.json(newRestaurant);
    } catch (error) {
+       }
+     }
--    const ratings = await getRatings();
++    const result = await addRating(parseInt(id), rating, review);
--
++    res.json(result);
--    const newRating = {
--      id: ratings.length + 1,
--      restaurant_id: parseInt(id),
--      rating,
--      review: review || null,
--      created_at: new Date().toISOString()
--    };
--
--    ratings.push(newRating);
--    await saveRatings(ratings);
--
--    res.json({
--      id: newRating.id,
--      message: 'Toast rating added successfully! 🍞'
--    });
    } catch (error) {
      console.error('Error adding rating:', error);
      res.status(500).json({ error: 'Failed to add rating' });
  app.get('/api/restaurants/:id/ratings', async (req, res) => {
    try {
      const { id } = req.params;
--    const ratings = await getRatings();
++    const ratings = await getRestaurantRatings(parseInt(id));
--
++    res.json(ratings);
--    const restaurantRatings = ratings
--      .filter(r => r.restaurant_id === parseInt(id))
--      .sort((a, b) => new Date(b.created_at) - new Date(a.created_at));
--
--    res.json(restaurantRatings);
    } catch (error) {
      console.error('Error fetching ratings:', error);
      res.status(500).json({ error: 'Failed to fetch ratings' });
        { place_id: 'seed_4', name: 'Crispy Corner', address: '400 Crunch St', latitude: parseFloat(lat) - 0.005, longitude: parseFloat(lng) - 0.005 }
      ];
--    const restaurants = await getRestaurants();
      let added = 0;
      for (const seedRestaurant of seedRestaurants) {
--      if (!restaurants.find(r => r.place_id === seedRestaurant.place_id)) {
++      try {
--        restaurants.push({
++        await addRestaurant(seedRestaurant);
--          id: restaurants.length + 1,
--          ...seedRestaurant,
--          created_at: new Date().toISOString()
--        });
          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);
++        }
+       }
+     }
--    await saveRestaurants(restaurants);
--
      res.json({ message: `Seeded ${added} restaurants with toast! 🍞` });
    } catch (error) {
      console.error('Error seeding data:', error);
+   }
  });
--// Initialize data files and start server
++// Migration endpoint (one-time use)
--initializeData().then(() => {
++app.post('/api/migrate', async (req, res) => {
--  app.listen(PORT, () => {
++  try {
--    console.log(`LocalToast backend running on http://localhost:${PORT} 🍞`);
++    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);
++  });