tanuki-s-forum/back/libs/mysql.js

const mysql = require("mysql");

function getConnection() {
  return mysql.createConnection({
    host: process.env.MYSQL_HOST,
    user: process.env.MYSQL_USER,
    password: process.env.MYSQL_PASSWORD,
    database: process.env.MYSQL_DATABASE,
  });
}

// +---------------------------+
// |          Users            |
// +---------------------------+

function addUser(connection, username, password) {
  return new Promise((resolve, reject) => {
    connection.query(
      `INSERT INTO users (username, password) VALUES (?, ?)`,
      [username, password],
      (error, result) => {
        if (error) {
          reject(new Error(error));
        }
        resolve(result);
      }
    );
  });
}

function deleteUser(connection, id) {
  return new Promise((resolve, reject) => {
    connection.query(
      `DELETE FROM users WHERE id = ?`,
      [id],
      (error, result) => {
        if (error) {
          reject(new Error(error));
        }
        resolve(result);
      }
    );
  });
}


function getUsers(connection) {
  return new Promise((resolve, reject) => {
    connection.query(
      `SELECT id, username, admin FROM users`,
      (error, result) => {
        if (error) {
          reject(new Error(error));
        }
        resolve(result);
      }
    );
  });
}

function getUser(connection, id) {
  return new Promise((resolve, reject) => {
    connection.query(
      `SELECT * FROM users WHERE id = ?`,
      [id],
      (error, result) => {
        if (error) {
          reject(new Error(error));
        }
        resolve(result);
      }
    );
  });
}

function getUserByUsername(connection, username) {
  return new Promise((resolve, reject) => {
    connection.query(
      `SELECT * FROM users WHERE username = ?`,
      [username],
      (error, result) => {
        if (error) {
          reject(new Error(error));
        }
        resolve(result);
      }
    );
  });
}

function searchUser(connection, search) {
  return new Promise((resolve, reject) => {
    connection.query(
      `SELECT * FROM users WHERE username LIKE ? LIMIT 5`,
      [`%${search}%`],
      (error, result) => {
        if (error) {
          reject(new Error(error));
        }
        resolve(result);
      }
    );
  });
}

function setUserPfp(connection, id, pfp) {
  return new Promise((resolve, reject) => {
    connection.query(
      `UPDATE users SET pfp = ? WHERE id = ?`,
      [pfp, id],
      (error, result) => {
        if (error) {
          reject(new Error(error));
        }
        resolve(result);
      }
    );
  });
}

function setUserUsername(connection, id, username) {
  return new Promise((resolve, reject) => {
    connection.query(
      `UPDATE users SET username = ? WHERE id = ?`,
      [username, id],
      (error, result) => {
        if (error) {
          reject(new Error(error));
        }
        resolve(result);
      }
    );
  });
}

function setUserPassword(connection, id, password) {
  return new Promise((resolve, reject) => {
    connection.query(
      `UPDATE users SET password = ? WHERE id = ?`,
      [password, id],
      (error, result) => {
        if (error) {
          reject(new Error(error));
        }
        resolve(result);
      }
    );
  });
}

// +---------------------------+
// |         Channels          |
// +---------------------------+

function addChannel(connection, name, description, owner_id) {
  return new Promise((resolve, reject) => {
    connection.query(
      `INSERT INTO channels (name, description, owner_id) VALUES (?, ?, ?)`,
      [name, description, owner_id],
      (error, result) => {
        if (error) {
          reject(new Error(error));
        }
        resolve(result);
      }
    );
  });
}

function deleteChannel(connection, channel_id) {
  return new Promise((resolve, reject) => {
    connection.query(
      `DELETE FROM channels WHERE id = ?`,
      [channel_id],
      (error, result) => {
        if (error) {
          reject(new Error(error));
        }
        resolve(result);
      }
    );
  });
}

function getChannels(connection) {
  return new Promise((resolve, reject) => {
    connection.query(
      `SELECT * FROM channels`,
      (error, result) => {
        if (error) {
          reject(new Error(error));
        }
        resolve(result);
      }
    );
  });
}

function getChannel(connection, name) {
  return new Promise((resolve, reject) => {
    connection.query(
      `SELECT channels.id, name, description, owner_id, username AS owner_username 
       FROM channels 
       JOIN users ON channels.owner_id = users.id 
       WHERE name = ?`,
      [name],
      (error, result) => {
        if (error) {
          reject(new Error(error));
        }
        resolve(result);
      }
    );
  });
}

function getActiveChannels(connection) {
  return new Promise((resolve, reject) => {
    connection.query(
      `SELECT channels.id, name, description, owner_id, username AS owner_username, count(*) AS message_count
       FROM messages
       JOIN channels ON messages.channel_id = channels.id
       JOIN users ON messages.user_id = users.id
       WHERE date > (SELECT max(date) FROM messages) - 3 * 24 * 60 * 60
       GROUP BY channel_id
       ORDER BY count(*) DESC
       LIMIT 5;`,
      (error, result) => {
        if (error) {
          reject(new Error(error));
        }
        resolve(result);
      }
    );
  });
}

function getNewChannels(connection) {
  return new Promise((resolve, reject) => {
    connection.query(
      `SELECT channels.id, name, description, owner_id, username AS owner_username 
       FROM channels 
       JOIN users ON channels.owner_id = users.id 
       ORDER BY channels.id DESC LIMIT 5`,
      (error, result) => {
        if (error) {
          reject(new Error(error));
        }
        resolve(result);
      }
    );
  });
}

function searchChannels(connection, search) {
  return new Promise((resolve, reject) => {
    connection.query(
      `SELECT channels.id, name, description, owner_id, username AS owner_username 
       FROM channels 
       JOIN users ON channels.owner_id = users.id 
       WHERE name LIKE ?
       LIMIT 5`,
      [`%${search}%`],
      (error, result) => {
        if (error) {
          reject(new Error(error));
        }
        resolve(result);
      }
    );
  });
}

// +---------------------------+
// |         Messages          |
// +---------------------------+

function addMessage(connection, channel_id, user_id, message) {
  return new Promise((resolve, reject) => {
    connection.query(
      `INSERT INTO messages (channel_id, user_id, content, date) VALUES (?, ?, ?, ?)`,
      [channel_id, user_id, message, Math.floor(Date.now() / 1000)],
      (error, result) => {
        if (error) {
          reject(new Error(error));
        }
        resolve(result);
      }
    );
  });
}

function addReply(connection, channel_id, user_id, message, message_id) {
  return new Promise((resolve, reject) => {
    connection.query(
      `INSERT INTO messages (channel_id, user_id, content, date, reply_to_id) VALUES (?, ?, ?, ?, ?)`,
      [channel_id, user_id, message, Math.floor(Date.now() / 1000), message_id],
      (error, result) => {
        if (error) {
          reject(new Error(error));
        }
        resolve(result);
      }
    );
  });
}

function deleteMessage(connection, message_id) {
  return new Promise((resolve, reject) => {
    connection.query(
      `DELETE FROM messages WHERE id = ?`,
      [message_id],
      (error, result) => {
        if (error) {
          reject(new Error(error));
        }
        resolve(result);
      }
    );
  });
}

function deleteChannelMessages(connection, channel_id) {
  return new Promise((resolve, reject) => {
    connection.query(
      `DELETE FROM messages WHERE channel_id = ?`,
      [channel_id],
      (error, result) => {
        if (error) {
          reject(new Error(error));
        }
        resolve(result);
      }
    );
  });
}

function getMessages(connection, channel_id, limit) {
  return new Promise((resolve, reject) => {
    connection.query(
      `SELECT messages.id, user_id, username, content, date, channels.name AS channel_name, has_replies
       FROM messages 
       JOIN users ON messages.user_id = users.id 
       JOIN channels ON messages.channel_id = channels.id 
       WHERE channel_id = ? AND reply_to_id IS NULL 
       ORDER BY date DESC
       LIMIT ?`,
      [channel_id, limit],
      (error, result) => {
        if (error) {
          reject(new Error(error));
        }
        resolve(result);
      }
    );
  });
}

function getMessage(connection, message_id) {
  return new Promise((resolve, reject) => {
    connection.query(
      `SELECT messages.id, user_id, username, content, date, channels.name AS channel_name, has_replies
       FROM messages 
       JOIN users ON messages.user_id = users.id 
       JOIN channels ON messages.channel_id = channels.id 
       WHERE messages.id = ?`,
      [message_id],
      (error, result) => {
        if (error) {
          reject(new Error(error));
        }
        resolve(result);
      }
    );
  });
}

function getLastMessages(connection) {
  return new Promise((resolve, reject) => {
    connection.query(
      `SELECT messages.id, user_id, username, content, date, channels.name AS channel_name, has_replies
       FROM messages 
       JOIN users ON messages.user_id = users.id 
       JOIN channels ON messages.channel_id = channels.id
       ORDER BY date DESC LIMIT 5`,
      (error, result) => {
        if (error) {
          reject(new Error(error));
        }
        resolve(result);
      }
    );
  });
}

function getUserLastMessages(connection, username) {
  return new Promise((resolve, reject) => {
    connection.query(
      `SELECT messages.id, user_id, username, content, date, channels.name AS channel_name, has_replies
       FROM messages 
       JOIN users ON messages.user_id = users.id 
       JOIN channels ON messages.channel_id = channels.id 
       WHERE username = ?
       ORDER BY date DESC LIMIT 5`,
      [username],
      (error, result) => {
        if (error) {
          reject(new Error(error));
        }
        resolve(result);
      }
    );
  });
}

function getMessageReplies(connection, message_id) {
  return new Promise((resolve, reject) => {
    connection.query(
      `SELECT messages.id, user_id, username, content, date, channels.name AS channel_name, has_replies 
       FROM messages 
       JOIN users ON messages.user_id = users.id 
       JOIN channels ON messages.channel_id = channels.id 
       WHERE reply_to_id = ?`,
      [message_id],
      (error, result) => {
        if (error) {
          reject(new Error(error));
        }
        resolve(result);
      }
    );
  });
}

function setHasReplies(connection, message_id, has_replies) {
  return new Promise((resolve, reject) => {
    connection.query(
      `UPDATE messages SET has_replies = ? WHERE id = ?`,
      [has_replies, message_id],
      (error, result) => {
        if (error) {
          reject(new Error(error));
        }
        resolve(result);
      }
    );
  });
}

// +---------------------------+
// |         Mentions          |
// +---------------------------+

function addMention(connection, message_id, user_id) {
  return new Promise((resolve, reject) => {
    connection.query(
      `INSERT INTO mentions (message_id, user_id) VALUES (?, ?)`,
      [message_id, user_id],
      (error, result) => {
        if (error) {
          reject(new Error(error));
        }
        resolve(result);
      }
    );
  });
}

function getMentions(connection, message_id) {
  return new Promise((resolve, reject) => {
    connection.query(
      `SELECT users.username FROM mentions 
       JOIN users ON mentions.user_id = users.id 
       WHERE message_id = ?`,
      [message_id],
      (error, result) => {
        if (error) {
          reject(new Error(error));
        }
        resolve(result);
      }
    );
  });
}

// +---------------------------+
// |          Emojis           |
// +---------------------------+

function addEmoji(connection, name, file) {
  return new Promise((resolve, reject) => {
    connection.query(
      `INSERT INTO emojis (name, file) VALUES (?, ?)`,
      [name, file],
      (error, result) => {
        if (error) {
          reject(new Error(error));
        }
        resolve(result);
      }
    );
  });
}

function deleteEmoji(connection, id) {
  return new Promise((resolve, reject) => {
    connection.query(
      `DELETE FROM emojis WHERE id = ?`,
      [id],
      (error, result) => {
        if (error) {
          reject(new Error(error));
        }
        resolve(result);
      }
    );
  });
}

function getEmojis(connection) {
  return new Promise((resolve, reject) => {
    connection.query(
      `SELECT id, name FROM emojis`,
      (error, result) => {
        if (error) {
          reject(new Error(error));
        }
        resolve(result);
      }
    );
  });
}

function getEmoji(connection, id) {
  return new Promise((resolve, reject) => {
    connection.query(
      `SELECT * FROM emojis WHERE id = ?`,
      [id],
      (error, result) => {
        if (error) {
          reject(new Error(error));
        }
        resolve(result);
      }
    );
  });
}

function getEmojiByName(connection, name) {
  return new Promise((resolve, reject) => {
    connection.query(
      `SELECT * FROM emojis WHERE name = ?`,
      [name],
      (error, result) => {
        if (error) {
          reject(new Error(error));
        }
        resolve(result);
      }
    );
  });
}

function searchEmojis(connection, search) {
  return new Promise((resolve, reject) => {
    connection.query(
      `SELECT * FROM emojis WHERE name LIKE ? LIMIT 5`,
      [`%${search}%`],
      (error, result) => {
        if (error) {
          reject(new Error(error));
        }
        resolve(result);
      }
    );
  });
}

module.exports = {
  getConnection,

  addUser,
  deleteUser,
  getUsers,
  getUser,
  searchUser,
  getUserByUsername,
  setUserPfp,
  setUserUsername,
  setUserPassword,

  addChannel,
  deleteChannel,
  getChannels,
  getChannel,
  getActiveChannels,
  getNewChannels,
  searchChannels,

  addMessage,
  addReply,
  deleteMessage,
  deleteChannelMessages,
  getMessages,
  getMessage,
  getUserLastMessages,
  getLastMessages,
  getMessageReplies,
  setHasReplies,

  addMention,
  getMentions,

  addEmoji,
  deleteEmoji,
  getEmojis,
  getEmoji,
  getEmojiByName,
  searchEmojis,
};