dist/server/chat-plugins/trivia/database.js

"use strict";
var __defProp = Object.defineProperty;
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
var __getOwnPropNames = Object.getOwnPropertyNames;
var __hasOwnProp = Object.prototype.hasOwnProperty;
var __export = (target, all) => {
  for (var name in all)
    __defProp(target, name, { get: all[name], enumerable: true });
};
var __copyProps = (to, from, except, desc) => {
  if (from && typeof from === "object" || typeof from === "function") {
    for (let key of __getOwnPropNames(from))
      if (!__hasOwnProp.call(to, key) && key !== except)
        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
  }
  return to;
};
var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
var database_exports = {};
__export(database_exports, {
  LEADERBOARD_ENUM: () => LEADERBOARD_ENUM,
  TriviaSQLiteDatabase: () => TriviaSQLiteDatabase
});
module.exports = __toCommonJS(database_exports);
var import_lib = require("../../../lib");
var import_utils = require("../../../lib/utils");
const LEADERBOARD_ENUM = {
  alltime: 1,
  nonAlltime: 0,
  cycle: 2
};
class TriviaSQLiteDatabase {
  constructor(legacyJSONPath) {
    this.legacyJSONPath = legacyJSONPath;
    this.leaderboardInsertion = null;
    this.questionInsertion = null;
    this.answerInsertion = null;
    this.gameHistoryInsertion = null;
    this.scoreHistoryInsertion = null;
    this.updateMoveEventQuestions = null;
    this.categoryChangeQuery = null;
    this.leaderboardChangeQuery = null;
    this.migrateCategoryQuery = null;
    this.historyQuery = null;
    this.historyScoresQuery = null;
    this.allQuestionsRandomOrderQuery = null;
    this.allQuestionsNewestFirstQuery = null;
    this.allQuestionsOldestFirstQuery = null;
    this.answersQuery = null;
    this.submissionsQuery = null;
    this.leaderboardQuery = null;
    this.leaderboardByUserQuery = null;
    this.scoreAndPointsByUser = null;
    this.eventQuestionQuery = null;
    this.categoriesQuery = null;
    this.questionCountQuery = null;
    this.categoryQuestionCountQuery = null;
    this.questionSearchQuery = null;
    this.questionExistsQuery = null;
    this.clearAllSubmissionsQuery = null;
    this.clearCategoryQuery = null;
    this.clearCycleLeaderboardQuery = null;
    this.deleteQuestionQuery = null;
    this.leaderboardDeletionQuery = null;
    this.readyPromise = this.prepareStatements().then(() => {
      void this.convertLegacyJSON();
      this.readyPromise = null;
    });
  }
  /***************************
   * Methods for adding data *
   ***************************/
  async updateLeaderboardForUser(userid, additions) {
    if (this.readyPromise)
      await this.readyPromise;
    if (!Config.usesqlite) {
      throw new Chat.ErrorMessage(`Can't update the leaderboard for ${userid} because SQLite is not enabled.`);
    }
    for (const [lb, discrim] of Object.entries(LEADERBOARD_ENUM)) {
      if (!additions[lb])
        continue;
      await this.leaderboardChangeQuery.run({
        score: additions[lb].score,
        totalPoints: additions[lb].totalPoints,
        totalCorrectAnswers: additions[lb].totalCorrectAnswers,
        userid,
        leaderboard: discrim
      });
    }
  }
  async addHistory(history) {
    if (this.readyPromise)
      await this.readyPromise;
    if (!Config.usesqlite) {
      throw new Chat.ErrorMessage(`Can't add a Trivia game to the history because SQLite is not enabled.`);
    }
    const res = await Chat.database.transaction("addHistory", {
      history,
      gameHistoryInsertion: this.gameHistoryInsertion.toString(),
      scoreHistoryInsertion: this.scoreHistoryInsertion.toString()
    });
    if (!res)
      throw new Error(`Error updating Trivia history.`);
  }
  async addQuestions(questions) {
    if (this.readyPromise)
      await this.readyPromise;
    if (!Config.usesqlite) {
      throw new Chat.ErrorMessage(`Can't add a Trivia question because SQLite is not enabled.`);
    }
    const res = await Chat.database.transaction("addQuestions", {
      questions,
      questionInsertion: this.questionInsertion.toString(),
      answerInsertion: this.answerInsertion.toString(),
      isSubmission: false
    });
    if (!res)
      throw new Chat.ErrorMessage(`Error adding Trivia questions.`);
  }
  async addQuestionSubmissions(questions) {
    if (this.readyPromise)
      await this.readyPromise;
    if (!Config.usesqlite) {
      throw new Chat.ErrorMessage(`Can't submit a Trivia question for review because SQLite is not enabled.`);
    }
    const res = await Chat.database.transaction("addQuestions", {
      questions,
      questionInsertion: this.questionInsertion.toString(),
      answerInsertion: this.answerInsertion.toString(),
      isSubmission: true
    });
    if (!res)
      throw new Chat.ErrorMessage(`Error adding Trivia questions for review.`);
  }
  async setShouldMoveEventQuestions(shouldMove) {
    if (this.readyPromise)
      await this.readyPromise;
    if (!Config.usesqlite) {
      throw new Chat.ErrorMessage(`Can't enable/disable moving event questions because SQLite is not enabled.`);
    }
    await this.updateMoveEventQuestions.run([Number(shouldMove)]);
  }
  /******************************
   * Methods for modifying data *
   ******************************/
  async mergeLeaderboardEntries(from, to) {
    if (this.readyPromise)
      await this.readyPromise;
    if (!Config.usesqlite) {
      throw new Chat.ErrorMessage(`Can't merge ${from} and ${to}'s Trivia leaderboard entries because SQLite is not enabled.`);
    }
    for (const lbDiscrim of Object.values(LEADERBOARD_ENUM)) {
      const fromScores = await this.scoreAndPointsByUser.get([from, lbDiscrim]) || {
        score: 0,
        totalCorrectAnswers: 0,
        totalPoints: 0
      };
      const toScores = await this.scoreAndPointsByUser.get([to, lbDiscrim]) || {
        score: 0,
        totalCorrectAnswers: 0,
        totalPoints: 0
      };
      toScores.score += fromScores.score;
      toScores.totalCorrectAnswers += fromScores.totalCorrectAnswers;
      toScores.totalPoints += fromScores.totalPoints;
      await Chat.database.run(
        this.leaderboardInsertion,
        [to, toScores.score, toScores.totalPoints, toScores.totalCorrectAnswers, lbDiscrim]
      );
      await this.leaderboardDeletionQuery.run([from, lbDiscrim]);
    }
  }
  async shouldMoveEventQuestions() {
    if (this.readyPromise)
      await this.readyPromise;
    if (!Config.usesqlite) {
      throw new Chat.ErrorMessage(`Can't find out if we are moving event questions because SQLite is not enabled.`);
    }
    return (await this.eventQuestionQuery.get([]) || { value: false }).value;
  }
  async moveQuestionToCategory(question, newCategory) {
    if (this.readyPromise)
      await this.readyPromise;
    if (!Config.usesqlite) {
      throw new Chat.ErrorMessage(`Can't move question category because SQLite is not enabled.`);
    }
    await this.categoryChangeQuery.run([newCategory, question]);
  }
  async migrateCategory(sourceCategory, targetCategory) {
    if (this.readyPromise)
      await this.readyPromise;
    if (!Config.usesqlite) {
      throw new Chat.ErrorMessage(`Can't migrate categories because SQLite is not enabled.`);
    }
    const { changes } = await this.migrateCategoryQuery.run([targetCategory, sourceCategory]);
    return changes;
  }
  async acceptSubmissions(submissions) {
    if (this.readyPromise)
      await this.readyPromise;
    if (!Config.usesqlite) {
      throw new Chat.ErrorMessage(`Can't accept Trivia question submissions because SQLite is not enabled.`);
    }
    await Chat.database.run(
      `UPDATE trivia_questions SET is_submission = 0 WHERE question IN (${(0, import_utils.formatSQLArray)(submissions)})`,
      submissions
    );
  }
  async editQuestion(oldQuestionText, newQuestionText, newAnswers) {
    if (this.readyPromise)
      await this.readyPromise;
    if (!Config.usesqlite) {
      throw new Chat.ErrorMessage(`Can't edit Trivia question because SQLite is not enabled.`);
    }
    await Chat.database.transaction("editQuestion", {
      oldQuestionText,
      newQuestionText,
      newAnswers
    });
  }
  /*****************************
   * Methods for fetching data *
   *****************************/
  async getHistory(numberOfLines = 10) {
    if (this.readyPromise)
      await this.readyPromise;
    if (!Config.usesqlite) {
      throw new Chat.ErrorMessage(`Can't get Trivia game history because SQLite is not enabled.`);
    }
    const rows = await this.historyQuery.all([numberOfLines]);
    return rows.map((row) => ({
      mode: row.mode,
      length: /^d+$/.test(row.length) ? parseInt(row.length) || row.length : row.length,
      category: row.category,
      creator: row.creator || void 0,
      givesPoints: row.givesPoints !== 0,
      startTime: row.time
    }));
  }
  async getScoresForLastGame() {
    if (this.readyPromise)
      await this.readyPromise;
    if (!Config.usesqlite) {
      throw new Chat.ErrorMessage(`Can't get Trivia game scores because SQLite is not enabled.`);
    }
    const { game_id } = await this.historyQuery.get([1]);
    const results = {};
    for (const row of await this.historyScoresQuery.all([game_id])) {
      results[row.userid] = row.score;
    }
    return results;
  }
  async getQuestions(categories, limit, options) {
    if (this.readyPromise)
      await this.readyPromise;
    if (!Config.usesqlite)
      throw new Chat.ErrorMessage(`Can't get Trivia questions because SQLite is not enabled.`);
    let query;
    let args;
    if (categories === "all") {
      if (options.order === "newestfirst") {
        query = this.allQuestionsNewestFirstQuery;
      } else if (options.order === "oldestfirst") {
        query = this.allQuestionsOldestFirstQuery;
      } else {
        query = this.allQuestionsRandomOrderQuery;
      }
      args = [limit];
    } else {
      query = `SELECT * FROM trivia_questions WHERE category IN (${(0, import_utils.formatSQLArray)(categories)}) AND is_submission = 0 ORDER BY ${options.order === "random" ? "RANDOM()" : `added_at ${options.order === "oldestfirst" ? "ASC" : "DESC"}`} LIMIT ?`;
      args = [...categories, limit];
    }
    if (!query)
      throw new Error(`Couldn't prepare query`);
    const rows = await Chat.database.all(query, args);
    return Promise.all(rows.map((row) => this.rowToQuestion(row)));
  }
  async getLeaderboardEntry(id, leaderboard) {
    if (this.readyPromise)
      await this.readyPromise;
    if (!Config.usesqlite) {
      throw new Chat.ErrorMessage(`Can't find out if user ${id} has a Trivia leaderboard entry because SQLite is not enabled.`);
    }
    const row = await this.leaderboardByUserQuery.get([id, LEADERBOARD_ENUM[leaderboard]]);
    if (!row)
      return null;
    return {
      score: row.score,
      totalPoints: row.total_points,
      totalCorrectAnswers: row.total_correct_answers
    };
  }
  async getLeaderboards() {
    if (this.readyPromise)
      await this.readyPromise;
    if (!Config.usesqlite) {
      throw new Chat.ErrorMessage(`Can't get the Trivia leaderboard scores because SQLite is not enabled.`);
    }
    const result = {
      alltime: {},
      nonAlltime: {},
      cycle: {}
    };
    const rows = await this.leaderboardQuery.all([]);
    for (const row of rows) {
      const entry = {
        score: row.score,
        totalPoints: row.total_points,
        totalCorrectAnswers: row.total_correct_answers
      };
      let leaderboard = null;
      for (const [lb, discrim] of Object.entries(LEADERBOARD_ENUM)) {
        if (discrim === row.leaderboard)
          leaderboard = lb;
      }
      if (leaderboard === null)
        throw new Error(`Invalid leaderboard value ${row.leaderboard}`);
      result[leaderboard][row.userid] = entry;
    }
    return result;
  }
  async getQuestion(questionText) {
    if (this.readyPromise)
      await this.readyPromise;
    if (!Config.usesqlite) {
      throw new Chat.ErrorMessage(`Can't check if a Trivia question already exists because SQLite is not enabled.`);
    }
    const row = await this.questionExistsQuery.get([questionText]);
    if (!row)
      return null;
    return this.rowToQuestion(row);
  }
  async ensureQuestionExists(questionText) {
    const question = await this.getQuestion(questionText);
    if (!question) {
      throw new Chat.ErrorMessage(`Question "${questionText}" is not in the question database.`);
    }
    return question;
  }
  async ensureQuestionDoesNotExist(questionText) {
    if (await this.getQuestion(questionText)) {
      throw new Chat.ErrorMessage(`Question "${questionText}" is already in the question database.`);
    }
  }
  async getSubmissions() {
    if (this.readyPromise)
      await this.readyPromise;
    if (!Config.usesqlite) {
      throw new Chat.ErrorMessage(`Can't retrieve the Trivia question submissions because SQLite is not enabled.`);
    }
    const rows = await this.submissionsQuery.all([]);
    return Promise.all(rows.map((row) => this.rowToQuestion(row)));
  }
  async getQuestionCounts() {
    if (this.readyPromise)
      await this.readyPromise;
    if (!Config.usesqlite) {
      throw new Chat.ErrorMessage(`Can't retrieve the Trivia question counts because SQLite is not enabled.`);
    }
    const allCategories = (await this.categoriesQuery.all([])).map((row) => row.category);
    const total = (await this.questionCountQuery.get([])).count;
    const result = { total };
    for (const category of allCategories) {
      result[category] = (await this.categoryQuestionCountQuery.get([category])).count;
    }
    return result;
  }
  async searchQuestions(search, options) {
    if (this.readyPromise)
      await this.readyPromise;
    if (!Config.usesqlite) {
      throw new Chat.ErrorMessage(`Can't search Trivia questions because SQLite is not enabled.`);
    }
    if (options.caseSensitive)
      await Chat.database.exec(`PRAGMA case_sensitive_like = true;`);
    const rows = await this.questionSearchQuery.all([`%${search}%`, Number(options.searchSubmissions)]);
    if (options.caseSensitive)
      await Chat.database.exec(`PRAGMA case_sensitive_like = false;`);
    return Promise.all(rows.map((row) => this.rowToQuestion(row)));
  }
  /*****************************
   * Methods for deleting data *
   * ***************************/
  async clearSubmissions() {
    if (this.readyPromise)
      await this.readyPromise;
    if (!Config.usesqlite) {
      throw new Chat.ErrorMessage(`Can't clear the Trivia question submissions because SQLite is not enabled.`);
    }
    await Chat.database.run(this.clearAllSubmissionsQuery, []);
  }
  async clearCategory(category) {
    if (this.readyPromise)
      await this.readyPromise;
    if (!Config.usesqlite) {
      throw new Chat.ErrorMessage(`Can't clear the Trivia questions in category "${category}" because SQLite is not enabled.`);
    }
    await Chat.database.run(this.clearCategoryQuery, [category]);
  }
  async clearCycleLeaderboard() {
    if (this.readyPromise)
      await this.readyPromise;
    if (!Config.usesqlite) {
      throw new Chat.ErrorMessage(`Can't clear the cycle leaderboard because SQLite is not enabled.`);
    }
    await Chat.database.run(this.clearCycleLeaderboardQuery);
  }
  async deleteQuestion(questionText) {
    if (this.readyPromise)
      await this.readyPromise;
    if (!Config.usesqlite) {
      throw new Chat.ErrorMessage(`Can't delete the Trivia question because SQLite is not enabled.`);
    }
    await Chat.database.run(this.deleteQuestionQuery, [questionText]);
  }
  async deleteLeaderboardEntry(userid, leaderboard) {
    if (this.readyPromise)
      await this.readyPromise;
    if (!Config.usesqlite) {
      throw new Chat.ErrorMessage(`Can't delete leaderboard entries because SQLite is not enabled.`);
    }
    await this.leaderboardDeletionQuery.run([userid, LEADERBOARD_ENUM[leaderboard]]);
  }
  async deleteSubmissions(submissions) {
    if (this.readyPromise)
      await this.readyPromise;
    if (!Config.usesqlite) {
      throw new Chat.ErrorMessage(`Can't delete Trivia question submissions because SQLite is not enabled.`);
    }
    const query = await Chat.database.prepare(
      `DELETE FROM trivia_questions WHERE is_submission = 1 AND question IN (${(0, import_utils.formatSQLArray)(submissions)})`
    );
    await query?.run(submissions);
  }
  /****************************************
   * Private helper methods	 			*
   * These are not part of the public API *
   ****************************************/
  async prepareStatements() {
    if (!Config.usesqlite)
      return;
    if (Chat.databaseReadyPromise)
      await Chat.databaseReadyPromise;
    this.leaderboardInsertion = await Chat.database.prepare(
      `INSERT OR REPLACE INTO trivia_leaderboard (userid, score, total_points, total_correct_answers, leaderboard) VALUES (?, ?, ?, ?, ?) `
    );
    this.questionInsertion = await Chat.database.prepare(
      `INSERT OR IGNORE INTO trivia_questions (question, category, added_at, userid, is_submission) VALUES (?, ?, ?, ?, ?)`
    );
    this.answerInsertion = await Chat.database.prepare(
      `INSERT INTO trivia_answers (question_id, answer) VALUES (?, ?)`
    );
    this.gameHistoryInsertion = await Chat.database.prepare(
      `INSERT INTO trivia_game_history (mode, length, category, time, creator, gives_points) VALUES (?, ?, ?, ?, ?, ?)`
    );
    this.scoreHistoryInsertion = await Chat.database.prepare(
      `INSERT INTO trivia_game_scores (game_id, userid, score) VALUES (?, ?, ?)`
    );
    this.updateMoveEventQuestions = await Chat.database.prepare(
      `INSERT OR REPLACE INTO trivia_settings (key, value) VALUES ('moveEventQuestions', ?)`
    );
    this.categoryChangeQuery = await Chat.database.prepare(
      `UPDATE trivia_questions SET category = ? WHERE question = ?`
    );
    this.leaderboardChangeQuery = await Chat.database.prepare(
      `INSERT INTO trivia_leaderboard (userid, score, total_points, total_correct_answers, leaderboard) VALUES ($userid, $score, $totalPoints, $totalCorrectAnswers, $leaderboard) ON CONFLICT DO UPDATE SET score = score + $score, total_points = total_points + $totalPoints, total_correct_answers = total_correct_answers + $totalCorrectAnswers WHERE userid = $userid AND leaderboard = $leaderboard`
    );
    this.migrateCategoryQuery = await Chat.database.prepare(
      `UPDATE OR REPLACE trivia_questions SET category = ? WHERE category = ?`
    );
    this.historyQuery = await Chat.database.prepare(
      `SELECT * FROM trivia_game_history ORDER BY time DESC LIMIT ?`
    );
    this.historyScoresQuery = await Chat.database.prepare(`SELECT userid, score FROM trivia_game_scores WHERE game_id = ?`);
    this.allQuestionsRandomOrderQuery = await Chat.database.prepare(
      `SELECT * FROM trivia_questions WHERE category IN ('ae', 'pokemon', 'sg', 'sh') AND is_submission = 0 ORDER BY RANDOM() LIMIT ?`
    );
    this.allQuestionsNewestFirstQuery = await Chat.database.prepare(
      `SELECT * FROM trivia_questions WHERE category IN ('ae', 'pokemon', 'sg', 'sh') AND is_submission = 0 ORDER BY added_at DESC LIMIT ?`
    );
    this.allQuestionsOldestFirstQuery = await Chat.database.prepare(
      `SELECT * FROM trivia_questions WHERE category IN ('ae', 'pokemon', 'sg', 'sh') AND is_submission = 0 ORDER BY added_at ASC LIMIT ?`
    );
    this.answersQuery = await Chat.database.prepare(
      `SELECT * FROM trivia_answers WHERE question_id = ?`
    );
    this.submissionsQuery = await Chat.database.prepare(
      `SELECT * FROM trivia_questions WHERE is_submission = 1 ORDER BY category ASC`
    );
    this.leaderboardQuery = await Chat.database.prepare(
      `SELECT * FROM trivia_leaderboard`
    );
    this.leaderboardByUserQuery = await Chat.database.prepare(
      `SELECT * FROM trivia_leaderboard WHERE userid = ? AND leaderboard = ?`
    );
    this.scoreAndPointsByUser = await Chat.database.prepare(
      `SELECT score, total_points as totalPoints, total_correct_answers as totalCorrectAnswers FROM trivia_leaderboard WHERE userid = ? AND leaderboard = ?`
    );
    this.eventQuestionQuery = await Chat.database.prepare(
      `SELECT * FROM trivia_settings WHERE key = 'moveEventQuestions'`
    );
    this.categoriesQuery = await Chat.database.prepare(
      `SELECT DISTINCT category FROM trivia_questions`
    );
    this.questionCountQuery = await Chat.database.prepare(
      `SELECT count(*) AS count FROM trivia_questions WHERE is_submission = 0`
    );
    this.categoryQuestionCountQuery = await Chat.database.prepare(
      `SELECT count(*) AS count FROM trivia_questions WHERE category = ? AND is_submission = 0`
    );
    this.questionSearchQuery = await Chat.database.prepare(
      `SELECT * FROM trivia_questions WHERE question LIKE ? AND is_submission = ? ORDER BY added_at DESC`
    );
    this.questionExistsQuery = await Chat.database.prepare(
      `SELECT * FROM trivia_questions WHERE question = ?`
    );
    this.leaderboardDeletionQuery = await Chat.database.prepare(
      `DELETE FROM trivia_leaderboard WHERE userid = ? AND leaderboard = ?`
    );
    this.clearAllSubmissionsQuery = await Chat.database.prepare(
      `DELETE FROM trivia_questions WHERE is_submission = 1`
    );
    this.clearCategoryQuery = await Chat.database.prepare(
      `DELETE FROM trivia_questions WHERE category = ? AND is_submission = 0`
    );
    this.clearCycleLeaderboardQuery = await Chat.database.prepare(
      `DELETE FROM trivia_leaderboard WHERE leaderboard = ${LEADERBOARD_ENUM.cycle}`
    );
    this.deleteQuestionQuery = await Chat.database.prepare(
      `DELETE FROM trivia_questions WHERE question = ?`
    );
    await Chat.database.exec("PRAGMA foreign_keys = ON;");
    await Chat.database.loadExtension("server/chat-plugins/trivia/transactions.js");
  }
  async convertLegacyJSON() {
    if (!Config.usesqlite || !this.legacyJSONPath)
      return;
    if (this.readyPromise)
      await this.readyPromise;
    let triviaData;
    try {
      triviaData = JSON.parse((0, import_lib.FS)(this.legacyJSONPath).readIfExistsSync() || "{}");
      if (!triviaData)
        throw new Error(`no JSON`);
    } catch {
      return;
    }
    if (Array.isArray(triviaData.submissions)) {
      const oldSubmissions = triviaData.submissions;
      triviaData.submissions = {};
      for (const question of oldSubmissions) {
        if (!(question.category in triviaData.submissions))
          triviaData.submissions[question.category] = [];
        triviaData.submissions[question.category].push(question);
      }
    }
    if (Array.isArray(triviaData.questions)) {
      const oldSubmissions = triviaData.questions;
      triviaData.questions = {};
      for (const question of oldSubmissions) {
        if (!(question.category in triviaData.questions))
          triviaData.questions[question.category] = [];
        triviaData.questions[question.category].push(question);
      }
    }
    if (typeof triviaData.leaderboard === "object") {
      for (const userid in triviaData.leaderboard) {
        const [score, totalGamePoints, totalCorrectAnswers] = triviaData.leaderboard[userid];
        await Chat.database.run(
          this.leaderboardInsertion,
          [userid, score, totalGamePoints, totalCorrectAnswers, Number(true)]
        );
      }
    }
    if (typeof triviaData.altLeaderboard === "object") {
      for (const userid in triviaData.altLeaderboard) {
        const [score, totalGamePoints, totalCorrectAnswers] = triviaData.altLeaderboard[userid];
        await Chat.database.run(
          this.leaderboardInsertion,
          [userid, score, totalGamePoints, totalCorrectAnswers, Number(false)]
        );
      }
    }
    const addedAt = Date.now();
    if (typeof triviaData.questions === "object") {
      for (const category in triviaData.questions) {
        for (const question of triviaData.questions[category]) {
          if (!question.addedAt)
            question.addedAt = addedAt;
          if (!question.user)
            question.user = "unknown user";
          question.question = question.question.trim();
          await this.addQuestions([question]);
        }
      }
    }
    if (typeof triviaData.submissions === "object") {
      for (const category in triviaData.submissions) {
        for (const question of triviaData.submissions[category]) {
          if (!question.addedAt)
            question.addedAt = addedAt;
          if (!question.user)
            question.user = "unknown user";
          question.question = question.question.trim();
          await this.addQuestionSubmissions([question]);
        }
      }
    }
    if (Array.isArray(triviaData.history)) {
      const now = Date.now();
      for (const game of triviaData.history) {
        if (!game.startTime)
          game.startTime = now;
        await this.addHistory([game]);
      }
    }
    if (triviaData.moveEventQuestions) {
      await this.setShouldMoveEventQuestions(true);
    }
    try {
      await (0, import_lib.FS)(this.legacyJSONPath).rename(this.legacyJSONPath + ".converted");
    } catch {
    }
  }
  rowToQuestion(row) {
    return Chat.database.all(this.answersQuery, [row.question_id]).then((answerRows) => ({
      question: row.question,
      category: row.category,
      answers: answerRows.map((answerRow) => answerRow.answer),
      user: row.userid,
      addedAt: row.added_at
    }));
  }
}
//# sourceMappingURL=database.js.map