726 lines
20 KiB
JavaScript
726 lines
20 KiB
JavaScript
const path = require('path')
|
|
const mysql = require('mysql2/promise')
|
|
const { Low } = require('lowdb')
|
|
const { JSONFile } = require('lowdb/node')
|
|
|
|
const DB_CLIENT = process.env.DB_CLIENT || 'lowdb'
|
|
|
|
const DB_HOST = process.env.DB_HOST || '127.0.0.1'
|
|
const DB_PORT = process.env.DB_PORT ? Number(process.env.DB_PORT) : 3306
|
|
const DB_USER = process.env.DB_USER || 'root'
|
|
const DB_PASSWORD = process.env.DB_PASSWORD || ''
|
|
const DB_NAME = process.env.DB_NAME || 'tier_cursor'
|
|
const DB_CONNECTION_LIMIT = process.env.DB_CONNECTION_LIMIT ? Number(process.env.DB_CONNECTION_LIMIT) : 10
|
|
|
|
const LOWDB_PATH = path.join(__dirname, '..', 'data', 'db.json')
|
|
|
|
let lowdbPromise = null
|
|
let poolPromise = null
|
|
let initPromise = null
|
|
|
|
function now() {
|
|
return Date.now()
|
|
}
|
|
|
|
function defaultData() {
|
|
return {
|
|
users: [],
|
|
games: [
|
|
{ id: 'example-game', name: '예시 게임', thumbnailSrc: '', createdAt: now() },
|
|
{ id: 'another-game', name: '다른 예시 게임', thumbnailSrc: '', createdAt: now() },
|
|
],
|
|
gameImages: [
|
|
{ id: 'img-1', gameId: 'example-game', src: '/uploads/seeds/example1.png', label: '샘플 1', createdAt: now() },
|
|
{ id: 'img-2', gameId: 'example-game', src: '/uploads/seeds/example2.png', label: '샘플 2', createdAt: now() },
|
|
],
|
|
customItems: [],
|
|
tierLists: [],
|
|
gameSuggestions: [],
|
|
}
|
|
}
|
|
|
|
function parseJson(value, fallback) {
|
|
if (!value) return fallback
|
|
try {
|
|
return JSON.parse(value)
|
|
} catch (e) {
|
|
return fallback
|
|
}
|
|
}
|
|
|
|
function serializeJson(value) {
|
|
return JSON.stringify(value || [])
|
|
}
|
|
|
|
function mapUserRow(row) {
|
|
if (!row) return null
|
|
return {
|
|
id: row.id,
|
|
email: row.email,
|
|
nickname: row.nickname || '',
|
|
isAdmin: !!row.is_admin,
|
|
avatarSrc: row.avatar_src || '',
|
|
createdAt: Number(row.created_at),
|
|
}
|
|
}
|
|
|
|
function mapGameRow(row) {
|
|
if (!row) return null
|
|
return {
|
|
id: row.id,
|
|
name: row.name,
|
|
thumbnailSrc: row.thumbnail_src || '',
|
|
createdAt: Number(row.created_at),
|
|
}
|
|
}
|
|
|
|
function mapGameItemRow(row) {
|
|
if (!row) return null
|
|
return {
|
|
id: row.id,
|
|
gameId: row.game_id,
|
|
src: row.src,
|
|
label: row.label,
|
|
createdAt: Number(row.created_at),
|
|
}
|
|
}
|
|
|
|
function mapTierListRow(row) {
|
|
if (!row) return null
|
|
return {
|
|
id: row.id,
|
|
authorId: row.author_id,
|
|
gameId: row.game_id,
|
|
title: row.title,
|
|
description: row.description || '',
|
|
isPublic: !!row.is_public,
|
|
groups: parseJson(row.groups_json, []),
|
|
pool: parseJson(row.pool_json, []),
|
|
createdAt: Number(row.created_at),
|
|
updatedAt: Number(row.updated_at),
|
|
}
|
|
}
|
|
|
|
async function getLowdb() {
|
|
if (lowdbPromise) return lowdbPromise
|
|
lowdbPromise = (async () => {
|
|
const adapter = new JSONFile(LOWDB_PATH)
|
|
const db = new Low(adapter, defaultData())
|
|
await db.read()
|
|
db.data ||= defaultData()
|
|
db.data.users ||= []
|
|
db.data.games ||= []
|
|
db.data.gameImages ||= []
|
|
db.data.customItems ||= []
|
|
db.data.tierLists ||= []
|
|
db.data.gameSuggestions ||= []
|
|
await db.write()
|
|
return db
|
|
})()
|
|
return lowdbPromise
|
|
}
|
|
|
|
async function createPool() {
|
|
const rootConnection = await mysql.createConnection({
|
|
host: DB_HOST,
|
|
port: DB_PORT,
|
|
user: DB_USER,
|
|
password: DB_PASSWORD,
|
|
multipleStatements: true,
|
|
})
|
|
|
|
await rootConnection.query(
|
|
`CREATE DATABASE IF NOT EXISTS \`${DB_NAME}\` CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci`
|
|
)
|
|
await rootConnection.end()
|
|
|
|
return mysql.createPool({
|
|
host: DB_HOST,
|
|
port: DB_PORT,
|
|
user: DB_USER,
|
|
password: DB_PASSWORD,
|
|
database: DB_NAME,
|
|
connectionLimit: DB_CONNECTION_LIMIT,
|
|
charset: 'utf8mb4',
|
|
})
|
|
}
|
|
|
|
async function getPool() {
|
|
if (!poolPromise) {
|
|
poolPromise = createPool()
|
|
}
|
|
return poolPromise
|
|
}
|
|
|
|
async function query(sql, params = []) {
|
|
const pool = await getPool()
|
|
const [rows] = await pool.execute(sql, params)
|
|
return rows
|
|
}
|
|
|
|
async function ensureMariaSchema() {
|
|
if (initPromise) return initPromise
|
|
initPromise = (async () => {
|
|
await query(`
|
|
CREATE TABLE IF NOT EXISTS users (
|
|
id VARCHAR(64) PRIMARY KEY,
|
|
email VARCHAR(255) NOT NULL UNIQUE,
|
|
nickname VARCHAR(80) NOT NULL DEFAULT '',
|
|
password_hash VARCHAR(255) NOT NULL,
|
|
is_admin TINYINT(1) NOT NULL DEFAULT 0,
|
|
avatar_src VARCHAR(255) NOT NULL DEFAULT '',
|
|
created_at BIGINT NOT NULL
|
|
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4
|
|
`)
|
|
|
|
await query(`
|
|
CREATE TABLE IF NOT EXISTS games (
|
|
id VARCHAR(120) PRIMARY KEY,
|
|
name VARCHAR(120) NOT NULL,
|
|
thumbnail_src VARCHAR(255) NOT NULL DEFAULT '',
|
|
created_at BIGINT NOT NULL
|
|
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4
|
|
`)
|
|
|
|
await query(`
|
|
CREATE TABLE IF NOT EXISTS game_items (
|
|
id VARCHAR(64) PRIMARY KEY,
|
|
game_id VARCHAR(120) NOT NULL,
|
|
src VARCHAR(255) NOT NULL,
|
|
label VARCHAR(120) NOT NULL,
|
|
created_at BIGINT NOT NULL,
|
|
INDEX idx_game_items_game_id (game_id),
|
|
CONSTRAINT fk_game_items_game FOREIGN KEY (game_id) REFERENCES games(id) ON DELETE CASCADE
|
|
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4
|
|
`)
|
|
|
|
await query(`
|
|
CREATE TABLE IF NOT EXISTS custom_items (
|
|
id VARCHAR(64) PRIMARY KEY,
|
|
owner_id VARCHAR(64) NOT NULL,
|
|
src VARCHAR(255) NOT NULL,
|
|
label VARCHAR(120) NOT NULL,
|
|
created_at BIGINT NOT NULL,
|
|
INDEX idx_custom_items_owner_id (owner_id),
|
|
CONSTRAINT fk_custom_items_owner FOREIGN KEY (owner_id) REFERENCES users(id) ON DELETE CASCADE
|
|
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4
|
|
`)
|
|
|
|
await query(`
|
|
CREATE TABLE IF NOT EXISTS tierlists (
|
|
id VARCHAR(64) PRIMARY KEY,
|
|
author_id VARCHAR(64) NOT NULL,
|
|
game_id VARCHAR(120) NOT NULL,
|
|
title VARCHAR(120) NOT NULL,
|
|
description TEXT NOT NULL,
|
|
is_public TINYINT(1) NOT NULL DEFAULT 0,
|
|
groups_json LONGTEXT NOT NULL,
|
|
pool_json LONGTEXT NOT NULL,
|
|
created_at BIGINT NOT NULL,
|
|
updated_at BIGINT NOT NULL,
|
|
INDEX idx_tierlists_author_id (author_id),
|
|
INDEX idx_tierlists_game_id (game_id),
|
|
INDEX idx_tierlists_public_game_updated (is_public, game_id, updated_at),
|
|
CONSTRAINT fk_tierlists_author FOREIGN KEY (author_id) REFERENCES users(id) ON DELETE CASCADE,
|
|
CONSTRAINT fk_tierlists_game FOREIGN KEY (game_id) REFERENCES games(id) ON DELETE CASCADE
|
|
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4
|
|
`)
|
|
|
|
await query(`
|
|
CREATE TABLE IF NOT EXISTS game_suggestions (
|
|
id VARCHAR(64) PRIMARY KEY,
|
|
name VARCHAR(120) NOT NULL,
|
|
created_at BIGINT NOT NULL
|
|
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4
|
|
`)
|
|
|
|
const countRows = await query('SELECT COUNT(*) AS count FROM games')
|
|
if (Number(countRows[0]?.count || 0) === 0) {
|
|
const createdAt = now()
|
|
await query(
|
|
`
|
|
INSERT INTO games (id, name, thumbnail_src, created_at)
|
|
VALUES
|
|
(?, ?, ?, ?),
|
|
(?, ?, ?, ?)
|
|
`,
|
|
['example-game', '예시 게임', '', createdAt, 'another-game', '다른 예시 게임', '', createdAt]
|
|
)
|
|
|
|
await query(
|
|
`
|
|
INSERT INTO game_items (id, game_id, src, label, created_at)
|
|
VALUES
|
|
(?, ?, ?, ?, ?),
|
|
(?, ?, ?, ?, ?)
|
|
`,
|
|
[
|
|
'img-1',
|
|
'example-game',
|
|
'/uploads/seeds/example1.png',
|
|
'샘플 1',
|
|
createdAt,
|
|
'img-2',
|
|
'example-game',
|
|
'/uploads/seeds/example2.png',
|
|
'샘플 2',
|
|
createdAt,
|
|
]
|
|
)
|
|
}
|
|
})()
|
|
|
|
return initPromise
|
|
}
|
|
|
|
async function ensureData() {
|
|
if (DB_CLIENT === 'mariadb') {
|
|
await ensureMariaSchema()
|
|
return
|
|
}
|
|
await getLowdb()
|
|
}
|
|
|
|
async function countUsers() {
|
|
if (DB_CLIENT === 'mariadb') {
|
|
const rows = await query('SELECT COUNT(*) AS count FROM users')
|
|
return Number(rows[0]?.count || 0)
|
|
}
|
|
const db = await getLowdb()
|
|
return db.data.users.length
|
|
}
|
|
|
|
async function findUserByEmail(email) {
|
|
if (DB_CLIENT === 'mariadb') {
|
|
const rows = await query(
|
|
'SELECT id, email, nickname, password_hash, is_admin, avatar_src, created_at FROM users WHERE email = ? LIMIT 1',
|
|
[email]
|
|
)
|
|
const row = rows[0]
|
|
if (!row) return null
|
|
return { ...mapUserRow(row), passwordHash: row.password_hash }
|
|
}
|
|
|
|
const db = await getLowdb()
|
|
return db.data.users.find((user) => user.email === email) || null
|
|
}
|
|
|
|
async function findUserById(id) {
|
|
if (DB_CLIENT === 'mariadb') {
|
|
const rows = await query(
|
|
'SELECT id, email, nickname, is_admin, avatar_src, created_at FROM users WHERE id = ? LIMIT 1',
|
|
[id]
|
|
)
|
|
return mapUserRow(rows[0])
|
|
}
|
|
|
|
const db = await getLowdb()
|
|
const user = db.data.users.find((entry) => entry.id === id)
|
|
if (!user) return null
|
|
return {
|
|
id: user.id,
|
|
email: user.email,
|
|
nickname: user.nickname || '',
|
|
isAdmin: !!user.isAdmin,
|
|
avatarSrc: user.avatarSrc || '',
|
|
createdAt: Number(user.createdAt),
|
|
}
|
|
}
|
|
|
|
async function createUser({ id, email, nickname, passwordHash, isAdmin }) {
|
|
if (DB_CLIENT === 'mariadb') {
|
|
const createdAt = now()
|
|
await query(
|
|
`
|
|
INSERT INTO users (id, email, nickname, password_hash, is_admin, avatar_src, created_at)
|
|
VALUES (?, ?, ?, ?, ?, ?, ?)
|
|
`,
|
|
[id, email, nickname || '', passwordHash, isAdmin ? 1 : 0, '', createdAt]
|
|
)
|
|
return findUserById(id)
|
|
}
|
|
|
|
const db = await getLowdb()
|
|
const user = {
|
|
id,
|
|
email,
|
|
nickname: nickname || '',
|
|
passwordHash,
|
|
isAdmin: !!isAdmin,
|
|
avatarSrc: '',
|
|
createdAt: now(),
|
|
}
|
|
db.data.users.push(user)
|
|
await db.write()
|
|
return findUserById(id)
|
|
}
|
|
|
|
async function updateUserProfile({ id, nickname, avatarSrc }) {
|
|
if (DB_CLIENT === 'mariadb') {
|
|
if (typeof avatarSrc === 'string') {
|
|
await query('UPDATE users SET nickname = ?, avatar_src = ? WHERE id = ?', [nickname || '', avatarSrc, id])
|
|
} else {
|
|
await query('UPDATE users SET nickname = ? WHERE id = ?', [nickname || '', id])
|
|
}
|
|
return findUserById(id)
|
|
}
|
|
|
|
const db = await getLowdb()
|
|
const user = db.data.users.find((entry) => entry.id === id)
|
|
if (!user) return null
|
|
user.nickname = nickname || ''
|
|
if (typeof avatarSrc === 'string') user.avatarSrc = avatarSrc
|
|
await db.write()
|
|
return findUserById(id)
|
|
}
|
|
|
|
async function listGames() {
|
|
if (DB_CLIENT === 'mariadb') {
|
|
const rows = await query('SELECT id, name, thumbnail_src, created_at FROM games ORDER BY created_at ASC, name ASC')
|
|
return rows.map(mapGameRow)
|
|
}
|
|
const db = await getLowdb()
|
|
return db.data.games.map((game) => ({
|
|
id: game.id,
|
|
name: game.name,
|
|
thumbnailSrc: game.thumbnailSrc || '',
|
|
createdAt: Number(game.createdAt),
|
|
}))
|
|
}
|
|
|
|
async function findGameById(id) {
|
|
if (DB_CLIENT === 'mariadb') {
|
|
const rows = await query('SELECT id, name, thumbnail_src, created_at FROM games WHERE id = ? LIMIT 1', [id])
|
|
return mapGameRow(rows[0])
|
|
}
|
|
const db = await getLowdb()
|
|
const game = db.data.games.find((entry) => entry.id === id)
|
|
if (!game) return null
|
|
return {
|
|
id: game.id,
|
|
name: game.name,
|
|
thumbnailSrc: game.thumbnailSrc || '',
|
|
createdAt: Number(game.createdAt),
|
|
}
|
|
}
|
|
|
|
async function listGameItems(gameId) {
|
|
if (DB_CLIENT === 'mariadb') {
|
|
const rows = await query(
|
|
'SELECT id, game_id, src, label, created_at FROM game_items WHERE game_id = ? ORDER BY created_at ASC',
|
|
[gameId]
|
|
)
|
|
return rows.map(mapGameItemRow)
|
|
}
|
|
const db = await getLowdb()
|
|
return db.data.gameImages
|
|
.filter((item) => item.gameId === gameId)
|
|
.map((item) => ({
|
|
id: item.id,
|
|
gameId: item.gameId,
|
|
src: item.src,
|
|
label: item.label,
|
|
createdAt: Number(item.createdAt),
|
|
}))
|
|
}
|
|
|
|
async function getGameDetail(gameId) {
|
|
const game = await findGameById(gameId)
|
|
if (!game) return null
|
|
const items = await listGameItems(gameId)
|
|
return { game, items }
|
|
}
|
|
|
|
async function createGame({ id, name }) {
|
|
if (DB_CLIENT === 'mariadb') {
|
|
await query('INSERT INTO games (id, name, thumbnail_src, created_at) VALUES (?, ?, ?, ?)', [id, name, '', now()])
|
|
return findGameById(id)
|
|
}
|
|
const db = await getLowdb()
|
|
db.data.games.push({ id, name, thumbnailSrc: '', createdAt: now() })
|
|
await db.write()
|
|
return findGameById(id)
|
|
}
|
|
|
|
async function updateGameThumbnail(gameId, thumbnailSrc) {
|
|
if (DB_CLIENT === 'mariadb') {
|
|
await query('UPDATE games SET thumbnail_src = ? WHERE id = ?', [thumbnailSrc, gameId])
|
|
return findGameById(gameId)
|
|
}
|
|
const db = await getLowdb()
|
|
const game = db.data.games.find((entry) => entry.id === gameId)
|
|
if (!game) return null
|
|
game.thumbnailSrc = thumbnailSrc
|
|
await db.write()
|
|
return findGameById(gameId)
|
|
}
|
|
|
|
async function createGameItem({ id, gameId, src, label }) {
|
|
if (DB_CLIENT === 'mariadb') {
|
|
const createdAt = now()
|
|
await query('INSERT INTO game_items (id, game_id, src, label, created_at) VALUES (?, ?, ?, ?, ?)', [
|
|
id,
|
|
gameId,
|
|
src,
|
|
label,
|
|
createdAt,
|
|
])
|
|
const rows = await query('SELECT id, game_id, src, label, created_at FROM game_items WHERE id = ? LIMIT 1', [id])
|
|
return mapGameItemRow(rows[0])
|
|
}
|
|
|
|
const db = await getLowdb()
|
|
const item = { id, gameId, src, label, createdAt: now() }
|
|
db.data.gameImages.push(item)
|
|
await db.write()
|
|
return {
|
|
id: item.id,
|
|
gameId: item.gameId,
|
|
src: item.src,
|
|
label: item.label,
|
|
createdAt: Number(item.createdAt),
|
|
}
|
|
}
|
|
|
|
async function createCustomItem({ id, ownerId, src, label }) {
|
|
if (DB_CLIENT === 'mariadb') {
|
|
const createdAt = now()
|
|
await query('INSERT INTO custom_items (id, owner_id, src, label, created_at) VALUES (?, ?, ?, ?, ?)', [
|
|
id,
|
|
ownerId,
|
|
src,
|
|
label,
|
|
createdAt,
|
|
])
|
|
return { id, ownerId, src, label, origin: 'custom', createdAt }
|
|
}
|
|
|
|
const db = await getLowdb()
|
|
const item = { id, ownerId, src, label, origin: 'custom', createdAt: now() }
|
|
db.data.customItems.push(item)
|
|
await db.write()
|
|
return item
|
|
}
|
|
|
|
async function createGameSuggestion({ id, name }) {
|
|
if (DB_CLIENT === 'mariadb') {
|
|
const createdAt = now()
|
|
await query('INSERT INTO game_suggestions (id, name, created_at) VALUES (?, ?, ?)', [id, name, createdAt])
|
|
return { id, name, createdAt }
|
|
}
|
|
const db = await getLowdb()
|
|
const suggestion = { id, name, createdAt: now() }
|
|
db.data.gameSuggestions.push(suggestion)
|
|
await db.write()
|
|
return suggestion
|
|
}
|
|
|
|
async function listPublicTierLists(gameId) {
|
|
if (DB_CLIENT === 'mariadb') {
|
|
const params = []
|
|
let whereClause = 'WHERE t.is_public = 1'
|
|
if (gameId) {
|
|
whereClause += ' AND t.game_id = ?'
|
|
params.push(gameId)
|
|
}
|
|
|
|
const rows = await query(
|
|
`
|
|
SELECT
|
|
t.id,
|
|
t.game_id,
|
|
t.title,
|
|
t.created_at,
|
|
t.updated_at,
|
|
t.author_id,
|
|
u.nickname,
|
|
u.email
|
|
FROM tierlists t
|
|
INNER JOIN users u ON u.id = t.author_id
|
|
${whereClause}
|
|
ORDER BY t.updated_at DESC
|
|
LIMIT 50
|
|
`,
|
|
params
|
|
)
|
|
|
|
return rows.map((row) => ({
|
|
id: row.id,
|
|
gameId: row.game_id,
|
|
title: row.title,
|
|
createdAt: Number(row.created_at),
|
|
updatedAt: Number(row.updated_at),
|
|
authorId: row.author_id,
|
|
authorName: row.nickname || row.email,
|
|
}))
|
|
}
|
|
|
|
const db = await getLowdb()
|
|
return db.data.tierLists
|
|
.filter((tierList) => tierList.isPublic && (!gameId || tierList.gameId === gameId))
|
|
.sort((a, b) => Number(b.updatedAt) - Number(a.updatedAt))
|
|
.slice(0, 50)
|
|
.map((tierList) => {
|
|
const author = db.data.users.find((user) => user.id === tierList.authorId)
|
|
return {
|
|
id: tierList.id,
|
|
gameId: tierList.gameId,
|
|
title: tierList.title,
|
|
createdAt: Number(tierList.createdAt),
|
|
updatedAt: Number(tierList.updatedAt),
|
|
authorId: tierList.authorId,
|
|
authorName: author?.nickname || author?.email || '알 수 없음',
|
|
}
|
|
})
|
|
}
|
|
|
|
async function listUserTierLists(userId) {
|
|
if (DB_CLIENT === 'mariadb') {
|
|
const rows = await query(
|
|
`
|
|
SELECT id, game_id, title, created_at, updated_at, is_public
|
|
FROM tierlists
|
|
WHERE author_id = ?
|
|
ORDER BY updated_at DESC
|
|
`,
|
|
[userId]
|
|
)
|
|
|
|
return rows.map((row) => ({
|
|
id: row.id,
|
|
gameId: row.game_id,
|
|
title: row.title,
|
|
createdAt: Number(row.created_at),
|
|
updatedAt: Number(row.updated_at),
|
|
isPublic: !!row.is_public,
|
|
}))
|
|
}
|
|
|
|
const db = await getLowdb()
|
|
return db.data.tierLists
|
|
.filter((tierList) => tierList.authorId === userId)
|
|
.sort((a, b) => Number(b.updatedAt) - Number(a.updatedAt))
|
|
.map((tierList) => ({
|
|
id: tierList.id,
|
|
gameId: tierList.gameId,
|
|
title: tierList.title,
|
|
createdAt: Number(tierList.createdAt),
|
|
updatedAt: Number(tierList.updatedAt),
|
|
isPublic: !!tierList.isPublic,
|
|
}))
|
|
}
|
|
|
|
async function findTierListById(id) {
|
|
if (DB_CLIENT === 'mariadb') {
|
|
const rows = await query(
|
|
`
|
|
SELECT id, author_id, game_id, title, description, is_public, groups_json, pool_json, created_at, updated_at
|
|
FROM tierlists
|
|
WHERE id = ?
|
|
LIMIT 1
|
|
`,
|
|
[id]
|
|
)
|
|
return mapTierListRow(rows[0])
|
|
}
|
|
|
|
const db = await getLowdb()
|
|
const tierList = db.data.tierLists.find((entry) => entry.id === id)
|
|
if (!tierList) return null
|
|
return {
|
|
id: tierList.id,
|
|
authorId: tierList.authorId,
|
|
gameId: tierList.gameId,
|
|
title: tierList.title,
|
|
description: tierList.description || '',
|
|
isPublic: !!tierList.isPublic,
|
|
groups: Array.isArray(tierList.groups) ? tierList.groups : [],
|
|
pool: Array.isArray(tierList.pool) ? tierList.pool : [],
|
|
createdAt: Number(tierList.createdAt),
|
|
updatedAt: Number(tierList.updatedAt),
|
|
}
|
|
}
|
|
|
|
async function saveTierList({ id, authorId, gameId, title, description, isPublic, groups, pool }) {
|
|
if (DB_CLIENT === 'mariadb') {
|
|
const existing = id ? await findTierListById(id) : null
|
|
|
|
if (existing) {
|
|
await query(
|
|
`
|
|
UPDATE tierlists
|
|
SET title = ?, description = ?, is_public = ?, groups_json = ?, pool_json = ?, updated_at = ?
|
|
WHERE id = ?
|
|
`,
|
|
[title, description || '', isPublic ? 1 : 0, serializeJson(groups), serializeJson(pool), now(), existing.id]
|
|
)
|
|
return findTierListById(existing.id)
|
|
}
|
|
|
|
const createdAt = now()
|
|
await query(
|
|
`
|
|
INSERT INTO tierlists (
|
|
id, author_id, game_id, title, description, is_public, groups_json, pool_json, created_at, updated_at
|
|
)
|
|
VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
|
|
`,
|
|
[id, authorId, gameId, title, description || '', isPublic ? 1 : 0, serializeJson(groups), serializeJson(pool), createdAt, createdAt]
|
|
)
|
|
return findTierListById(id)
|
|
}
|
|
|
|
const db = await getLowdb()
|
|
const existing = db.data.tierLists.find((entry) => entry.id === id)
|
|
if (existing) {
|
|
existing.title = title
|
|
existing.description = description || ''
|
|
existing.isPublic = !!isPublic
|
|
existing.groups = groups
|
|
existing.pool = pool
|
|
existing.updatedAt = now()
|
|
await db.write()
|
|
return findTierListById(existing.id)
|
|
}
|
|
|
|
const tierList = {
|
|
id,
|
|
authorId,
|
|
gameId,
|
|
title,
|
|
description: description || '',
|
|
isPublic: !!isPublic,
|
|
groups,
|
|
pool,
|
|
createdAt: now(),
|
|
updatedAt: now(),
|
|
}
|
|
db.data.tierLists.push(tierList)
|
|
await db.write()
|
|
return findTierListById(id)
|
|
}
|
|
|
|
module.exports = {
|
|
DB_CLIENT,
|
|
DB_NAME,
|
|
ensureData,
|
|
countUsers,
|
|
findUserByEmail,
|
|
findUserById,
|
|
createUser,
|
|
updateUserProfile,
|
|
listGames,
|
|
findGameById,
|
|
listGameItems,
|
|
getGameDetail,
|
|
createGame,
|
|
updateGameThumbnail,
|
|
createGameItem,
|
|
createCustomItem,
|
|
createGameSuggestion,
|
|
listPublicTierLists,
|
|
listUserTierLists,
|
|
findTierListById,
|
|
saveTierList,
|
|
}
|