3611 lines
120 KiB
JavaScript
3611 lines
120 KiB
JavaScript
const fs = require('fs/promises')
|
|
const path = require('path')
|
|
const mysql = require('mysql2/promise')
|
|
const { nanoid } = require('nanoid')
|
|
|
|
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 FREEFORM_TOPIC_ID = 'freeform'
|
|
const TOPIC_SLUG_PATTERN = /^[a-z0-9]+(?:-[a-z0-9]+)*$/
|
|
|
|
let poolPromise = null
|
|
let initPromise = null
|
|
|
|
function now() {
|
|
return Date.now()
|
|
}
|
|
|
|
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 normalizeTags(tags) {
|
|
const values = Array.isArray(tags)
|
|
? tags
|
|
: typeof tags === 'string'
|
|
? tags.split(',')
|
|
: []
|
|
return Array.from(
|
|
new Set(
|
|
values
|
|
.map((tag) => String(tag || '').trim().replace(/^#/, '').slice(0, 40))
|
|
.filter(Boolean)
|
|
)
|
|
).slice(0, 30)
|
|
}
|
|
|
|
function normalizeTopicSlug(value) {
|
|
return String(value || '').trim().toLowerCase()
|
|
}
|
|
|
|
function assertTopicSlug(slug) {
|
|
const normalized = normalizeTopicSlug(slug)
|
|
if (!normalized || normalized.length > 120 || !TOPIC_SLUG_PATTERN.test(normalized)) {
|
|
const err = new Error('topic_slug_invalid')
|
|
err.code = 'TOPIC_SLUG_INVALID'
|
|
throw err
|
|
}
|
|
return normalized
|
|
}
|
|
|
|
function collectUploadSrcsFromItems(items, bucket) {
|
|
for (const item of items || []) {
|
|
if (typeof item?.src === 'string' && item.src.startsWith('/uploads/')) {
|
|
bucket.add(item.src)
|
|
}
|
|
}
|
|
}
|
|
|
|
function resolveMonthRange(month) {
|
|
if (typeof month !== 'string') return null
|
|
const match = month.trim().match(/^(\d{4})-(\d{2})$/)
|
|
if (!match) return null
|
|
|
|
const year = Number(match[1])
|
|
const monthIndex = Number(match[2]) - 1
|
|
if (!Number.isInteger(year) || monthIndex < 0 || monthIndex > 11) return null
|
|
|
|
return {
|
|
start: new Date(year, monthIndex, 1).getTime(),
|
|
end: new Date(year, monthIndex + 1, 1).getTime(),
|
|
}
|
|
}
|
|
|
|
function mapUserRow(row) {
|
|
if (!row) return null
|
|
return {
|
|
id: row.id,
|
|
email: row.email,
|
|
nickname: row.nickname || '',
|
|
nicknameUpdatedAt: Number(row.nickname_updated_at || 0),
|
|
emailVerified: row.email_verified == null ? true : !!row.email_verified,
|
|
isAdmin: !!row.is_admin,
|
|
avatarSrc: row.avatar_src || '',
|
|
createdAt: Number(row.created_at),
|
|
tierListCount: Number(row.tierlist_count || 0),
|
|
followerCount: Number(row.follower_count || 0),
|
|
receivedFavoriteCount: Number(row.received_favorite_count || 0),
|
|
lastLoginAt: Number(row.last_login_at || 0),
|
|
recentActivityAt: Number(row.recent_activity_at || row.created_at || 0),
|
|
}
|
|
}
|
|
|
|
function mapTopicRow(row) {
|
|
if (!row) return null
|
|
return {
|
|
id: row.id,
|
|
slug: row.slug || row.id,
|
|
name: row.name,
|
|
topicId: row.id,
|
|
topicSlug: row.slug || row.id,
|
|
topicName: row.name,
|
|
thumbnailSrc: row.thumbnail_src || '',
|
|
isPublic: row.is_public == null ? true : !!row.is_public,
|
|
displayRank: row.display_rank == null ? null : Number(row.display_rank),
|
|
createdAt: Number(row.created_at),
|
|
tags: normalizeTags(parseJson(row.tags_json, [])),
|
|
}
|
|
}
|
|
|
|
function mapTopicItemRow(row) {
|
|
if (!row) return null
|
|
return {
|
|
id: row.id,
|
|
topicId: row.topic_id,
|
|
src: row.src,
|
|
label: row.label,
|
|
displayOrder: row.display_order == null ? null : Number(row.display_order),
|
|
createdAt: Number(row.created_at),
|
|
tags: normalizeTags(parseJson(row.tags_json, [])),
|
|
}
|
|
}
|
|
|
|
function mapCustomItemRow(row) {
|
|
if (!row) return null
|
|
return {
|
|
id: row.id,
|
|
ownerId: row.owner_id,
|
|
src: row.src,
|
|
label: row.label,
|
|
createdAt: Number(row.created_at),
|
|
replacedByItemId: row.replaced_by_item_id || '',
|
|
replacedBySrc: row.replaced_by_src || '',
|
|
replacedByLabel: row.replaced_by_label || '',
|
|
replacedAt: Number(row.replaced_at || 0),
|
|
tags: normalizeTags(parseJson(row.tags_json, [])),
|
|
}
|
|
}
|
|
|
|
function getSharedItemDisplayPriority(item) {
|
|
if (!item) return 99
|
|
if (item.sourceType === 'user' && !item.replacedAt) return 0
|
|
if (item.sourceType === 'user') return 1
|
|
if (item.sourceType === 'template') return 2
|
|
if (item.sourceType === 'asset' || item.isAssetLibraryItem) return 3
|
|
return 4
|
|
}
|
|
|
|
function collapseSharedLibraryItems(items) {
|
|
const grouped = new Map()
|
|
for (const item of items || []) {
|
|
const key = String(item?.src || '').trim()
|
|
if (!key) continue
|
|
if (!grouped.has(key)) grouped.set(key, [])
|
|
grouped.get(key).push(item)
|
|
}
|
|
|
|
return Array.from(grouped.values())
|
|
.map((group) =>
|
|
group
|
|
.slice()
|
|
.sort((a, b) => {
|
|
const priorityDiff = getSharedItemDisplayPriority(a) - getSharedItemDisplayPriority(b)
|
|
if (priorityDiff !== 0) return priorityDiff
|
|
return Number(b.createdAt || 0) - Number(a.createdAt || 0)
|
|
})[0]
|
|
)
|
|
.sort((a, b) => Number(b.createdAt || 0) - Number(a.createdAt || 0))
|
|
}
|
|
|
|
function mapImageAssetRow(row) {
|
|
if (!row) return null
|
|
return {
|
|
id: row.id,
|
|
contentHash: row.content_hash,
|
|
src: row.src || '',
|
|
labelOverride: row.label_override || '',
|
|
mimeType: row.mime_type || 'image/webp',
|
|
byteSize: Number(row.byte_size || 0),
|
|
originalByteSize: Number(row.original_byte_size || 0),
|
|
width: Number(row.width || 0),
|
|
height: Number(row.height || 0),
|
|
createdAt: Number(row.created_at || 0),
|
|
}
|
|
}
|
|
|
|
function mapImageOptimizationJobRow(row) {
|
|
if (!row) return null
|
|
return {
|
|
id: row.id,
|
|
status: row.status,
|
|
sourceCategory: row.source_category || '',
|
|
targetDirectory: row.target_directory || '',
|
|
originalByteSize: Number(row.original_byte_size || 0),
|
|
optimizedByteSize: Number(row.optimized_byte_size || 0),
|
|
reusedAsset: !!row.reused_asset,
|
|
errorMessage: row.error_message || '',
|
|
queuedAt: Number(row.queued_at || 0),
|
|
startedAt: Number(row.started_at || 0),
|
|
finishedAt: Number(row.finished_at || 0),
|
|
}
|
|
}
|
|
function mapTierListRow(row) {
|
|
if (!row) return null
|
|
return {
|
|
id: row.id,
|
|
authorId: row.author_id,
|
|
authorName: getUserDisplayName(row),
|
|
authorAccountName: getUserAccountName(row),
|
|
authorAvatarSrc: row.avatar_src || '',
|
|
topicId: row.topic_id,
|
|
topicSlug: row.topic_slug || row.topic_id,
|
|
topicName: row.topic_name || '',
|
|
title: row.title,
|
|
thumbnailSrc: row.thumbnail_src || '',
|
|
description: row.description || '',
|
|
isPublic: !!row.is_public,
|
|
isFeatured: !!row.is_featured,
|
|
featuredAt: Number(row.featured_at || 0),
|
|
featuredBy: row.featured_by || '',
|
|
showCharacterNames: !!row.show_character_names,
|
|
iconSize: Number(row.icon_size || 80),
|
|
sourceTierListId: row.source_tierlist_id || '',
|
|
sourceSnapshotTitle: row.source_snapshot_title || '',
|
|
sourceSnapshotAuthor: row.source_snapshot_author || '',
|
|
groups: parseJson(row.groups_json, []),
|
|
pool: parseJson(row.pool_json, []),
|
|
createdAt: Number(row.created_at),
|
|
updatedAt: Number(row.updated_at),
|
|
}
|
|
}
|
|
|
|
function mapTierListCommentRow(row) {
|
|
if (!row) return null
|
|
return {
|
|
id: row.id,
|
|
tierListId: row.tierlist_id,
|
|
parentCommentId: row.parent_comment_id || '',
|
|
authorId: row.author_id,
|
|
authorName: getUserDisplayName(row),
|
|
authorAccountName: getUserAccountName(row),
|
|
authorAvatarSrc: row.avatar_src || '',
|
|
content: row.content || '',
|
|
createdAt: Number(row.created_at || 0),
|
|
updatedAt: Number(row.updated_at || 0),
|
|
replies: [],
|
|
}
|
|
}
|
|
|
|
function mapCommentNotificationRow(row) {
|
|
if (!row) return null
|
|
return {
|
|
id: row.id,
|
|
userId: row.user_id,
|
|
tierListId: row.tierlist_id,
|
|
topicId: row.topic_id,
|
|
topicSlug: row.topic_slug || row.topic_id,
|
|
topicName: row.topic_name || '',
|
|
tierListTitle: row.tierlist_title || '',
|
|
tierListThumbnailSrc: row.tierlist_thumbnail_src || '',
|
|
commentId: row.comment_id,
|
|
parentCommentId: row.parent_comment_id || '',
|
|
parentCommentContent: row.parent_comment_content || '',
|
|
parentCommentCreatedAt: Number(row.parent_comment_created_at || 0),
|
|
parentAuthorName: getUserDisplayName({
|
|
nickname: row.parent_author_nickname,
|
|
email: row.parent_author_email,
|
|
}),
|
|
parentAuthorAccountName: getUserAccountName({
|
|
email: row.parent_author_email,
|
|
}),
|
|
parentAuthorAvatarSrc: row.parent_author_avatar_src || '',
|
|
notificationType: row.notification_type || 'tierlist_comment',
|
|
isRead: !!row.is_read,
|
|
readAt: Number(row.read_at || 0),
|
|
createdAt: Number(row.created_at || 0),
|
|
actorId: row.actor_user_id,
|
|
actorName: getUserDisplayName({
|
|
nickname: row.actor_nickname,
|
|
email: row.actor_email,
|
|
}),
|
|
actorAccountName: getUserAccountName({
|
|
email: row.actor_email,
|
|
}),
|
|
actorAvatarSrc: row.actor_avatar_src || '',
|
|
commentContent: row.comment_content || '',
|
|
}
|
|
}
|
|
|
|
function mapTemplateRequestRow(row) {
|
|
if (!row) return null
|
|
return {
|
|
id: row.id,
|
|
type: row.request_type,
|
|
requesterId: row.requester_id,
|
|
requesterName: getUserDisplayName(row),
|
|
requesterAccountName: getUserAccountName(row),
|
|
requesterAvatarSrc: row.requester_avatar_src || '',
|
|
sourceTierListId: row.source_tierlist_id || '',
|
|
sourceTopicId: row.source_topic_id,
|
|
sourceTopicSlug: row.source_topic_slug || row.source_topic_id,
|
|
sourceTopicName: row.source_topic_name || '',
|
|
sourceTierListTitle: row.title_snapshot || '',
|
|
sourceDescription: row.description_snapshot || '',
|
|
thumbnailSrc: row.thumbnail_src_snapshot || '',
|
|
targetTopicId: row.target_topic_id || '',
|
|
targetTopicSlug: row.target_topic_slug || row.target_topic_id || '',
|
|
targetTopicName: row.target_topic_name || '',
|
|
status: row.status,
|
|
items: parseJson(row.items_json, []),
|
|
snapshotGroups: parseJson(row.groups_json, []),
|
|
snapshotItems: parseJson(row.board_items_json, []),
|
|
snapshotShowCharacterNames: !!row.show_character_names_snapshot,
|
|
createdAt: Number(row.created_at),
|
|
updatedAt: Number(row.updated_at),
|
|
}
|
|
}
|
|
|
|
function getUserDisplayName(row) {
|
|
if (!row) return ''
|
|
const nickname = (row.nickname || '').trim()
|
|
if (nickname) return nickname
|
|
const email = (row.email || '').trim()
|
|
if (!email) return ''
|
|
return email.split('@')[0] || email
|
|
}
|
|
|
|
function getUserAccountName(row) {
|
|
if (!row) return ''
|
|
const email = (row.email || '').trim()
|
|
if (!email) return ''
|
|
return email.split('@')[0] || email
|
|
}
|
|
|
|
function getAssetLibrarySourceLabel(src) {
|
|
const normalizedSrc = String(src || '').trim()
|
|
if (normalizedSrc.includes('/uploads/assets/avatars/')) return '프로필 아바타'
|
|
if (normalizedSrc.includes('/uploads/assets/tierlists/')) return '티어표 썸네일'
|
|
if (normalizedSrc.includes('/uploads/assets/topics/')) return '썸네일 이미지'
|
|
return '보관 자산'
|
|
}
|
|
|
|
function getAssetLibraryKind(src) {
|
|
const normalizedSrc = String(src || '').trim()
|
|
if (normalizedSrc.includes('/uploads/assets/avatars/')) return 'avatar'
|
|
if (normalizedSrc.includes('/uploads/assets/tierlists/') || normalizedSrc.includes('/uploads/assets/topics/')) return 'thumbnail'
|
|
return 'asset'
|
|
}
|
|
|
|
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 closePool() {
|
|
if (!poolPromise) return
|
|
const pool = await poolPromise
|
|
await pool.end()
|
|
poolPromise = null
|
|
initPromise = null
|
|
}
|
|
|
|
async function ensureSchema() {
|
|
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 '',
|
|
nickname_updated_at BIGINT NOT NULL DEFAULT 0,
|
|
password_hash VARCHAR(255) NOT NULL,
|
|
email_verified TINYINT(1) NOT NULL DEFAULT 1,
|
|
is_admin TINYINT(1) NOT NULL DEFAULT 0,
|
|
avatar_src VARCHAR(255) NOT NULL DEFAULT '',
|
|
last_login_at BIGINT NOT NULL DEFAULT 0,
|
|
created_at BIGINT NOT NULL
|
|
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4
|
|
`)
|
|
|
|
await query(`
|
|
CREATE TABLE IF NOT EXISTS email_verification_tokens (
|
|
id VARCHAR(64) PRIMARY KEY,
|
|
user_id VARCHAR(64) NOT NULL,
|
|
token_hash CHAR(64) NOT NULL UNIQUE,
|
|
expires_at BIGINT NOT NULL,
|
|
consumed_at BIGINT NOT NULL DEFAULT 0,
|
|
created_at BIGINT NOT NULL,
|
|
INDEX idx_email_verification_user (user_id, consumed_at, expires_at),
|
|
INDEX idx_email_verification_expires (expires_at),
|
|
CONSTRAINT fk_email_verification_user FOREIGN KEY (user_id) REFERENCES users(id) ON DELETE CASCADE
|
|
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4
|
|
`)
|
|
|
|
await query(`
|
|
CREATE TABLE IF NOT EXISTS password_reset_tokens (
|
|
id VARCHAR(64) PRIMARY KEY,
|
|
user_id VARCHAR(64) NOT NULL,
|
|
token_hash CHAR(64) NOT NULL UNIQUE,
|
|
expires_at BIGINT NOT NULL,
|
|
consumed_at BIGINT NOT NULL DEFAULT 0,
|
|
created_at BIGINT NOT NULL,
|
|
INDEX idx_password_reset_user (user_id, consumed_at, expires_at),
|
|
INDEX idx_password_reset_expires (expires_at),
|
|
CONSTRAINT fk_password_reset_user FOREIGN KEY (user_id) REFERENCES users(id) ON DELETE CASCADE
|
|
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4
|
|
`)
|
|
|
|
await query(`
|
|
CREATE TABLE IF NOT EXISTS topics (
|
|
id VARCHAR(120) PRIMARY KEY,
|
|
slug VARCHAR(120) NOT NULL,
|
|
name VARCHAR(120) NOT NULL,
|
|
thumbnail_src VARCHAR(255) NOT NULL DEFAULT '',
|
|
tags_json LONGTEXT NULL,
|
|
is_public TINYINT(1) NOT NULL DEFAULT 1,
|
|
display_rank INT NULL DEFAULT NULL,
|
|
created_at BIGINT NOT NULL,
|
|
UNIQUE KEY uq_topics_slug (slug)
|
|
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4
|
|
`)
|
|
|
|
await query(`
|
|
CREATE TABLE IF NOT EXISTS topic_items (
|
|
id VARCHAR(64) PRIMARY KEY,
|
|
topic_id VARCHAR(120) NOT NULL,
|
|
src VARCHAR(255) NOT NULL,
|
|
label VARCHAR(120) NOT NULL,
|
|
tags_json LONGTEXT NULL,
|
|
display_order INT NULL DEFAULT NULL,
|
|
created_at BIGINT NOT NULL,
|
|
INDEX idx_topic_items_topic_id (topic_id),
|
|
CONSTRAINT fk_topic_items_topic FOREIGN KEY (topic_id) REFERENCES topics(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,
|
|
tags_json LONGTEXT NULL,
|
|
replaced_by_item_id VARCHAR(64) NOT NULL DEFAULT '',
|
|
replaced_by_src VARCHAR(255) NOT NULL DEFAULT '',
|
|
replaced_by_label VARCHAR(120) NOT NULL DEFAULT '',
|
|
replaced_at BIGINT NOT NULL DEFAULT 0,
|
|
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(`ALTER TABLE users ADD COLUMN IF NOT EXISTS nickname_updated_at BIGINT NOT NULL DEFAULT 0 AFTER nickname`)
|
|
await query(`UPDATE users SET nickname_updated_at = created_at WHERE nickname_updated_at = 0`)
|
|
await query(`ALTER TABLE topics ADD COLUMN IF NOT EXISTS tags_json LONGTEXT NULL AFTER thumbnail_src`)
|
|
await query(`ALTER TABLE topic_items ADD COLUMN IF NOT EXISTS tags_json LONGTEXT NULL AFTER label`)
|
|
await query(`ALTER TABLE custom_items ADD COLUMN IF NOT EXISTS tags_json LONGTEXT NULL AFTER label`)
|
|
await query(`ALTER TABLE custom_items ADD COLUMN IF NOT EXISTS replaced_by_item_id VARCHAR(64) NOT NULL DEFAULT '' AFTER label`)
|
|
await query(`ALTER TABLE custom_items ADD COLUMN IF NOT EXISTS replaced_by_src VARCHAR(255) NOT NULL DEFAULT '' AFTER replaced_by_item_id`)
|
|
await query(`ALTER TABLE custom_items ADD COLUMN IF NOT EXISTS replaced_by_label VARCHAR(120) NOT NULL DEFAULT '' AFTER replaced_by_src`)
|
|
await query(`ALTER TABLE custom_items ADD COLUMN IF NOT EXISTS replaced_at BIGINT NOT NULL DEFAULT 0 AFTER replaced_by_label`)
|
|
|
|
await query(`
|
|
CREATE TABLE IF NOT EXISTS tierlists (
|
|
id VARCHAR(64) PRIMARY KEY,
|
|
author_id VARCHAR(64) NOT NULL,
|
|
topic_id VARCHAR(120) NOT NULL,
|
|
title VARCHAR(120) NOT NULL,
|
|
thumbnail_src VARCHAR(255) NOT NULL DEFAULT '',
|
|
description TEXT NOT NULL,
|
|
is_public TINYINT(1) NOT NULL DEFAULT 0,
|
|
is_featured TINYINT(1) NOT NULL DEFAULT 0,
|
|
featured_at BIGINT NOT NULL DEFAULT 0,
|
|
featured_by VARCHAR(64) NOT NULL DEFAULT '',
|
|
show_character_names TINYINT(1) NOT NULL DEFAULT 0,
|
|
icon_size INT NOT NULL DEFAULT 80,
|
|
source_tierlist_id VARCHAR(64) NULL DEFAULT NULL,
|
|
source_snapshot_title VARCHAR(120) NOT NULL DEFAULT '',
|
|
source_snapshot_author VARCHAR(120) NOT NULL DEFAULT '',
|
|
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_topic_id (topic_id),
|
|
INDEX idx_tierlists_public_topic_updated (is_public, topic_id, updated_at),
|
|
INDEX idx_tierlists_featured_topic (is_public, is_featured, topic_id, featured_at),
|
|
CONSTRAINT fk_tierlists_author FOREIGN KEY (author_id) REFERENCES users(id) ON DELETE CASCADE,
|
|
CONSTRAINT fk_tierlists_topic FOREIGN KEY (topic_id) REFERENCES topics(id) ON DELETE CASCADE
|
|
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4
|
|
`)
|
|
|
|
await query(`
|
|
CREATE TABLE IF NOT EXISTS favorite_tierlists (
|
|
user_id VARCHAR(64) NOT NULL,
|
|
tierlist_id VARCHAR(64) NOT NULL,
|
|
created_at BIGINT NOT NULL,
|
|
PRIMARY KEY (user_id, tierlist_id),
|
|
INDEX idx_favorite_tierlists_tierlist_id (tierlist_id),
|
|
CONSTRAINT fk_favorite_tierlists_user FOREIGN KEY (user_id) REFERENCES users(id) ON DELETE CASCADE,
|
|
CONSTRAINT fk_favorite_tierlists_tierlist FOREIGN KEY (tierlist_id) REFERENCES tierlists(id) ON DELETE CASCADE
|
|
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4
|
|
`)
|
|
|
|
await query(`
|
|
CREATE TABLE IF NOT EXISTS favorite_topics (
|
|
user_id VARCHAR(64) NOT NULL,
|
|
topic_id VARCHAR(120) NOT NULL,
|
|
created_at BIGINT NOT NULL,
|
|
PRIMARY KEY (user_id, topic_id),
|
|
INDEX idx_favorite_topics_topic_id (topic_id),
|
|
CONSTRAINT fk_favorite_topics_user FOREIGN KEY (user_id) REFERENCES users(id) ON DELETE CASCADE,
|
|
CONSTRAINT fk_favorite_topics_topic FOREIGN KEY (topic_id) REFERENCES topics(id) ON DELETE CASCADE
|
|
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4
|
|
`)
|
|
|
|
await query(`
|
|
CREATE TABLE IF NOT EXISTS tierlist_comments (
|
|
id VARCHAR(64) PRIMARY KEY,
|
|
tierlist_id VARCHAR(64) NOT NULL,
|
|
author_id VARCHAR(64) NOT NULL,
|
|
parent_comment_id VARCHAR(64) NULL DEFAULT NULL,
|
|
content TEXT NOT NULL,
|
|
created_at BIGINT NOT NULL,
|
|
updated_at BIGINT NOT NULL,
|
|
INDEX idx_tierlist_comments_tierlist_created (tierlist_id, created_at),
|
|
INDEX idx_tierlist_comments_parent (parent_comment_id),
|
|
CONSTRAINT fk_tierlist_comments_tierlist FOREIGN KEY (tierlist_id) REFERENCES tierlists(id) ON DELETE CASCADE,
|
|
CONSTRAINT fk_tierlist_comments_author FOREIGN KEY (author_id) REFERENCES users(id) ON DELETE CASCADE,
|
|
CONSTRAINT fk_tierlist_comments_parent FOREIGN KEY (parent_comment_id) REFERENCES tierlist_comments(id) ON DELETE CASCADE
|
|
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4
|
|
`)
|
|
|
|
await query(`
|
|
CREATE TABLE IF NOT EXISTS comment_notifications (
|
|
id VARCHAR(64) PRIMARY KEY,
|
|
user_id VARCHAR(64) NOT NULL,
|
|
tierlist_id VARCHAR(64) NOT NULL,
|
|
comment_id VARCHAR(64) NOT NULL,
|
|
actor_user_id VARCHAR(64) NOT NULL,
|
|
notification_type VARCHAR(32) NOT NULL,
|
|
is_read TINYINT(1) NOT NULL DEFAULT 0,
|
|
read_at BIGINT NOT NULL DEFAULT 0,
|
|
created_at BIGINT NOT NULL,
|
|
INDEX idx_comment_notifications_user_read_created (user_id, is_read, created_at),
|
|
INDEX idx_comment_notifications_comment (comment_id),
|
|
CONSTRAINT fk_comment_notifications_user FOREIGN KEY (user_id) REFERENCES users(id) ON DELETE CASCADE,
|
|
CONSTRAINT fk_comment_notifications_tierlist FOREIGN KEY (tierlist_id) REFERENCES tierlists(id) ON DELETE CASCADE,
|
|
CONSTRAINT fk_comment_notifications_comment FOREIGN KEY (comment_id) REFERENCES tierlist_comments(id) ON DELETE CASCADE,
|
|
CONSTRAINT fk_comment_notifications_actor FOREIGN KEY (actor_user_id) REFERENCES users(id) ON DELETE CASCADE
|
|
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4
|
|
`)
|
|
await query(`ALTER TABLE tierlist_comments ADD COLUMN IF NOT EXISTS parent_comment_id VARCHAR(64) NULL DEFAULT NULL AFTER author_id`)
|
|
await query(`ALTER TABLE tierlist_comments ADD COLUMN IF NOT EXISTS updated_at BIGINT NOT NULL DEFAULT 0 AFTER created_at`)
|
|
await query(`ALTER TABLE comment_notifications ADD COLUMN IF NOT EXISTS actor_user_id VARCHAR(64) NOT NULL DEFAULT '' AFTER comment_id`)
|
|
await query(`ALTER TABLE comment_notifications ADD COLUMN IF NOT EXISTS notification_type VARCHAR(32) NOT NULL DEFAULT 'tierlist_comment' AFTER actor_user_id`)
|
|
await query(`ALTER TABLE comment_notifications ADD COLUMN IF NOT EXISTS is_read TINYINT(1) NOT NULL DEFAULT 0 AFTER notification_type`)
|
|
await query(`ALTER TABLE comment_notifications ADD COLUMN IF NOT EXISTS read_at BIGINT NOT NULL DEFAULT 0 AFTER is_read`)
|
|
await query(`CREATE INDEX IF NOT EXISTS idx_comment_notifications_user_read_created ON comment_notifications (user_id, is_read, created_at)`)
|
|
await query(`CREATE INDEX IF NOT EXISTS idx_comment_notifications_comment ON comment_notifications (comment_id)`)
|
|
|
|
await query(`
|
|
CREATE TABLE IF NOT EXISTS user_follows (
|
|
follower_id VARCHAR(64) NOT NULL,
|
|
following_id VARCHAR(64) NOT NULL,
|
|
created_at BIGINT NOT NULL,
|
|
PRIMARY KEY (follower_id, following_id),
|
|
INDEX idx_user_follows_following (following_id, created_at),
|
|
CONSTRAINT fk_user_follows_follower FOREIGN KEY (follower_id) REFERENCES users(id) ON DELETE CASCADE,
|
|
CONSTRAINT fk_user_follows_following FOREIGN KEY (following_id) REFERENCES users(id) ON DELETE CASCADE
|
|
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4
|
|
`)
|
|
|
|
await query(`
|
|
CREATE TABLE IF NOT EXISTS image_assets (
|
|
id VARCHAR(64) PRIMARY KEY,
|
|
content_hash CHAR(64) NOT NULL UNIQUE,
|
|
src VARCHAR(255) NOT NULL UNIQUE,
|
|
label_override VARCHAR(120) NOT NULL DEFAULT '',
|
|
mime_type VARCHAR(32) NOT NULL DEFAULT 'image/webp',
|
|
byte_size INT UNSIGNED NOT NULL,
|
|
original_byte_size INT UNSIGNED NOT NULL,
|
|
width INT UNSIGNED NOT NULL DEFAULT 0,
|
|
height INT UNSIGNED NOT NULL DEFAULT 0,
|
|
created_at BIGINT NOT NULL,
|
|
INDEX idx_image_assets_created_at (created_at)
|
|
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4
|
|
`)
|
|
|
|
await query(`
|
|
CREATE TABLE IF NOT EXISTS image_optimization_jobs (
|
|
id VARCHAR(64) PRIMARY KEY,
|
|
status VARCHAR(20) NOT NULL DEFAULT 'queued',
|
|
source_category VARCHAR(40) NOT NULL DEFAULT '',
|
|
target_directory VARCHAR(40) NOT NULL DEFAULT '',
|
|
original_byte_size INT UNSIGNED NOT NULL DEFAULT 0,
|
|
optimized_byte_size INT UNSIGNED NOT NULL DEFAULT 0,
|
|
reused_asset TINYINT(1) NOT NULL DEFAULT 0,
|
|
error_message VARCHAR(255) NOT NULL DEFAULT '',
|
|
queued_at BIGINT NOT NULL,
|
|
started_at BIGINT NOT NULL DEFAULT 0,
|
|
finished_at BIGINT NOT NULL DEFAULT 0,
|
|
INDEX idx_image_optimization_jobs_status_queued (status, queued_at),
|
|
INDEX idx_image_optimization_jobs_finished_at (finished_at)
|
|
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4
|
|
`)
|
|
await query(`
|
|
CREATE TABLE IF NOT EXISTS template_requests (
|
|
id VARCHAR(64) PRIMARY KEY,
|
|
request_type VARCHAR(20) NOT NULL,
|
|
requester_id VARCHAR(64) NOT NULL,
|
|
source_tierlist_id VARCHAR(64) NULL DEFAULT NULL,
|
|
source_topic_id VARCHAR(120) NOT NULL,
|
|
target_topic_id VARCHAR(120) NOT NULL DEFAULT '',
|
|
status VARCHAR(20) NOT NULL DEFAULT 'pending',
|
|
title_snapshot VARCHAR(120) NOT NULL,
|
|
description_snapshot TEXT NOT NULL,
|
|
thumbnail_src_snapshot VARCHAR(255) NOT NULL DEFAULT '',
|
|
items_json LONGTEXT NOT NULL,
|
|
groups_json LONGTEXT NOT NULL,
|
|
board_items_json LONGTEXT NOT NULL,
|
|
show_character_names_snapshot TINYINT(1) NOT NULL DEFAULT 0,
|
|
created_at BIGINT NOT NULL,
|
|
updated_at BIGINT NOT NULL,
|
|
INDEX idx_template_requests_status_created (status, created_at),
|
|
INDEX idx_template_requests_source_tierlist (source_tierlist_id),
|
|
INDEX idx_template_requests_requester (requester_id),
|
|
CONSTRAINT fk_template_requests_requester FOREIGN KEY (requester_id) REFERENCES users(id) ON DELETE CASCADE,
|
|
CONSTRAINT fk_template_requests_source_tierlist FOREIGN KEY (source_tierlist_id) REFERENCES tierlists(id) ON DELETE CASCADE
|
|
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4
|
|
`)
|
|
|
|
await query(
|
|
`
|
|
INSERT INTO topics (id, slug, name, thumbnail_src, tags_json, is_public, created_at)
|
|
VALUES (?, ?, ?, ?, ?, ?, ?)
|
|
ON DUPLICATE KEY UPDATE slug = VALUES(slug), name = VALUES(name), tags_json = VALUES(tags_json), is_public = VALUES(is_public)
|
|
`,
|
|
[FREEFORM_TOPIC_ID, FREEFORM_TOPIC_ID, '직접 티어표 만들기', '', '[]', 1, now()]
|
|
)
|
|
})()
|
|
|
|
return initPromise
|
|
}
|
|
|
|
async function ensureData() {
|
|
await ensureSchema()
|
|
}
|
|
|
|
async function countUsers() {
|
|
const rows = await query('SELECT COUNT(*) AS count FROM users')
|
|
return Number(rows[0]?.count || 0)
|
|
}
|
|
|
|
async function findUserByEmail(email) {
|
|
const rows = await query(
|
|
'SELECT id, email, nickname, nickname_updated_at, password_hash, email_verified, is_admin, avatar_src, last_login_at, created_at FROM users WHERE email = ? LIMIT 1',
|
|
[email]
|
|
)
|
|
const row = rows[0]
|
|
if (!row) return null
|
|
return { ...mapUserRow(row), passwordHash: row.password_hash }
|
|
}
|
|
|
|
async function findUserByNickname(nickname, excludeUserId = '') {
|
|
const normalized = String(nickname || '').trim()
|
|
if (!normalized) return null
|
|
const rows = excludeUserId
|
|
? await query(
|
|
`
|
|
SELECT id, email, nickname, nickname_updated_at, password_hash, email_verified, is_admin, avatar_src, last_login_at, created_at
|
|
FROM users
|
|
WHERE TRIM(LOWER(nickname)) = TRIM(LOWER(?)) AND id <> ?
|
|
LIMIT 1
|
|
`,
|
|
[normalized, excludeUserId]
|
|
)
|
|
: await query(
|
|
`
|
|
SELECT id, email, nickname, nickname_updated_at, password_hash, email_verified, is_admin, avatar_src, last_login_at, created_at
|
|
FROM users
|
|
WHERE TRIM(LOWER(nickname)) = TRIM(LOWER(?))
|
|
LIMIT 1
|
|
`,
|
|
[normalized]
|
|
)
|
|
const row = rows[0]
|
|
if (!row) return null
|
|
return { ...mapUserRow(row), passwordHash: row.password_hash }
|
|
}
|
|
|
|
async function findUserById(id) {
|
|
const rows = await query(
|
|
'SELECT id, email, nickname, nickname_updated_at, email_verified, is_admin, avatar_src, last_login_at, created_at FROM users WHERE id = ? LIMIT 1',
|
|
[id]
|
|
)
|
|
return mapUserRow(rows[0])
|
|
}
|
|
|
|
async function createUser({ id, email, nickname, passwordHash, emailVerified = true, isAdmin }) {
|
|
const createdAt = now()
|
|
await query(
|
|
`
|
|
INSERT INTO users (id, email, nickname, nickname_updated_at, password_hash, email_verified, is_admin, avatar_src, last_login_at, created_at)
|
|
VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
|
|
`,
|
|
[id, email, nickname || '', createdAt, passwordHash, emailVerified ? 1 : 0, isAdmin ? 1 : 0, '', isAdmin ? createdAt : 0, createdAt]
|
|
)
|
|
return findUserById(id)
|
|
}
|
|
|
|
async function touchUserLastLoginAt(userId, timestamp = now()) {
|
|
const lastLoginAt = Number(timestamp) || now()
|
|
const staleBefore = lastLoginAt - 10 * 60 * 1000
|
|
await query(
|
|
'UPDATE users SET last_login_at = ? WHERE id = ? AND last_login_at < ?',
|
|
[lastLoginAt, userId, staleBefore]
|
|
)
|
|
return findUserById(userId)
|
|
}
|
|
|
|
async function updateUserPassword({ id, passwordHash }) {
|
|
await query('UPDATE users SET password_hash = ? WHERE id = ?', [passwordHash, id])
|
|
return findUserById(id)
|
|
}
|
|
|
|
async function verifyUserEmail(userId) {
|
|
await query('UPDATE users SET email_verified = 1 WHERE id = ?', [userId])
|
|
return findUserById(userId)
|
|
}
|
|
|
|
async function createEmailVerificationToken({ id, userId, tokenHash, expiresAt }) {
|
|
const createdAt = now()
|
|
await query('UPDATE email_verification_tokens SET consumed_at = ? WHERE user_id = ? AND consumed_at = 0', [createdAt, userId])
|
|
await query(
|
|
`
|
|
INSERT INTO email_verification_tokens (id, user_id, token_hash, expires_at, consumed_at, created_at)
|
|
VALUES (?, ?, ?, ?, ?, ?)
|
|
`,
|
|
[id, userId, tokenHash, expiresAt, 0, createdAt]
|
|
)
|
|
return {
|
|
id,
|
|
userId,
|
|
tokenHash,
|
|
expiresAt,
|
|
consumedAt: 0,
|
|
createdAt,
|
|
}
|
|
}
|
|
|
|
async function findEmailVerificationTokenByHash(tokenHash) {
|
|
const rows = await query(
|
|
`
|
|
SELECT
|
|
id,
|
|
user_id,
|
|
token_hash,
|
|
expires_at,
|
|
consumed_at,
|
|
created_at
|
|
FROM email_verification_tokens
|
|
WHERE token_hash = ?
|
|
LIMIT 1
|
|
`,
|
|
[tokenHash]
|
|
)
|
|
const row = rows[0]
|
|
if (!row) return null
|
|
return {
|
|
id: row.id,
|
|
userId: row.user_id,
|
|
tokenHash: row.token_hash,
|
|
expiresAt: Number(row.expires_at || 0),
|
|
consumedAt: Number(row.consumed_at || 0),
|
|
createdAt: Number(row.created_at || 0),
|
|
}
|
|
}
|
|
|
|
async function consumeEmailVerificationToken(tokenId) {
|
|
await query('UPDATE email_verification_tokens SET consumed_at = ? WHERE id = ? AND consumed_at = 0', [now(), tokenId])
|
|
}
|
|
|
|
async function createPasswordResetToken({ id, userId, tokenHash, expiresAt }) {
|
|
const createdAt = now()
|
|
await query('UPDATE password_reset_tokens SET consumed_at = ? WHERE user_id = ? AND consumed_at = 0', [createdAt, userId])
|
|
await query(
|
|
`
|
|
INSERT INTO password_reset_tokens (id, user_id, token_hash, expires_at, consumed_at, created_at)
|
|
VALUES (?, ?, ?, ?, ?, ?)
|
|
`,
|
|
[id, userId, tokenHash, expiresAt, 0, createdAt]
|
|
)
|
|
return {
|
|
id,
|
|
userId,
|
|
tokenHash,
|
|
expiresAt,
|
|
consumedAt: 0,
|
|
createdAt,
|
|
}
|
|
}
|
|
|
|
async function findPasswordResetTokenByHash(tokenHash) {
|
|
const rows = await query(
|
|
`
|
|
SELECT
|
|
id,
|
|
user_id,
|
|
token_hash,
|
|
expires_at,
|
|
consumed_at,
|
|
created_at
|
|
FROM password_reset_tokens
|
|
WHERE token_hash = ?
|
|
LIMIT 1
|
|
`,
|
|
[tokenHash]
|
|
)
|
|
const row = rows[0]
|
|
if (!row) return null
|
|
return {
|
|
id: row.id,
|
|
userId: row.user_id,
|
|
tokenHash: row.token_hash,
|
|
expiresAt: Number(row.expires_at || 0),
|
|
consumedAt: Number(row.consumed_at || 0),
|
|
createdAt: Number(row.created_at || 0),
|
|
}
|
|
}
|
|
|
|
async function consumePasswordResetToken(tokenId) {
|
|
await query('UPDATE password_reset_tokens SET consumed_at = ? WHERE id = ? AND consumed_at = 0', [now(), tokenId])
|
|
}
|
|
|
|
async function updateUserProfile({ id, nickname, avatarSrc, touchNicknameUpdatedAt = false }) {
|
|
if (typeof avatarSrc === 'string') {
|
|
await query(
|
|
`UPDATE users
|
|
SET nickname = ?, avatar_src = ?, nickname_updated_at = CASE WHEN ? = 1 THEN ? ELSE nickname_updated_at END
|
|
WHERE id = ?`,
|
|
[nickname || '', avatarSrc, touchNicknameUpdatedAt ? 1 : 0, touchNicknameUpdatedAt ? now() : 0, id]
|
|
)
|
|
} else {
|
|
await query(
|
|
`UPDATE users
|
|
SET nickname = ?, nickname_updated_at = CASE WHEN ? = 1 THEN ? ELSE nickname_updated_at END
|
|
WHERE id = ?`,
|
|
[nickname || '', touchNicknameUpdatedAt ? 1 : 0, touchNicknameUpdatedAt ? now() : 0, id]
|
|
)
|
|
}
|
|
return findUserById(id)
|
|
}
|
|
|
|
async function findPrimaryAdminUser() {
|
|
const rows = await query(
|
|
'SELECT id, email, nickname, email_verified, is_admin, avatar_src, last_login_at, created_at FROM users WHERE is_admin = 1 ORDER BY created_at ASC, email ASC LIMIT 1'
|
|
)
|
|
return mapUserRow(rows[0])
|
|
}
|
|
|
|
async function listUsers({ queryText = '', sort = 'recent', direction = 'desc' } = {}) {
|
|
const where = []
|
|
const params = []
|
|
const trimmedQuery = typeof queryText === 'string' ? queryText.trim() : ''
|
|
|
|
if (trimmedQuery) {
|
|
where.push('(u.email LIKE ? OR u.nickname LIKE ?)')
|
|
params.push(`%${trimmedQuery}%`, `%${trimmedQuery}%`)
|
|
}
|
|
|
|
const isAsc = direction === 'asc'
|
|
const orderBy =
|
|
sort === 'created'
|
|
? isAsc
|
|
? 'u.created_at ASC, recent_activity_at ASC, u.email ASC'
|
|
: 'u.created_at DESC, recent_activity_at DESC, u.email ASC'
|
|
: sort === 'tierlists'
|
|
? isAsc
|
|
? 'tierlist_count ASC, recent_activity_at ASC, u.email ASC'
|
|
: 'tierlist_count DESC, recent_activity_at DESC, u.email ASC'
|
|
: sort === 'followers'
|
|
? isAsc
|
|
? 'follower_count ASC, recent_activity_at ASC, u.email ASC'
|
|
: 'follower_count DESC, recent_activity_at DESC, u.email ASC'
|
|
: sort === 'favorites'
|
|
? isAsc
|
|
? 'received_favorite_count ASC, recent_activity_at ASC, u.email ASC'
|
|
: 'received_favorite_count DESC, recent_activity_at DESC, u.email ASC'
|
|
: sort === 'lastLogin'
|
|
? isAsc
|
|
? 'u.last_login_at ASC, recent_activity_at ASC, u.email ASC'
|
|
: 'u.last_login_at DESC, recent_activity_at DESC, u.email ASC'
|
|
: isAsc
|
|
? 'recent_activity_at ASC, u.created_at ASC, u.email ASC'
|
|
: 'recent_activity_at DESC, u.created_at ASC, u.email ASC'
|
|
|
|
const rows = await query(
|
|
`
|
|
SELECT
|
|
u.id,
|
|
u.email,
|
|
u.nickname,
|
|
u.email_verified,
|
|
u.is_admin,
|
|
u.avatar_src,
|
|
u.last_login_at,
|
|
u.created_at,
|
|
COUNT(DISTINCT t.id) AS tierlist_count,
|
|
COUNT(DISTINCT uf.follower_id) AS follower_count,
|
|
COUNT(DISTINCT ft.user_id, ft.tierlist_id) AS received_favorite_count,
|
|
GREATEST(
|
|
u.created_at,
|
|
COALESCE(MAX(t.updated_at), 0)
|
|
) AS recent_activity_at
|
|
FROM users u
|
|
LEFT JOIN tierlists t ON t.author_id = u.id
|
|
LEFT JOIN user_follows uf ON uf.following_id = u.id
|
|
LEFT JOIN favorite_tierlists ft ON ft.tierlist_id = t.id
|
|
${where.length ? `WHERE ${where.join(' AND ')}` : ''}
|
|
GROUP BY u.id, u.email, u.nickname, u.email_verified, u.is_admin, u.avatar_src, u.last_login_at, u.created_at
|
|
ORDER BY ${orderBy}
|
|
`,
|
|
params
|
|
)
|
|
return rows.map(mapUserRow)
|
|
}
|
|
|
|
async function adminUpdateUser({ id, email, nickname, isAdmin, avatarSrc }) {
|
|
if (typeof avatarSrc === 'string') {
|
|
await query('UPDATE users SET email = ?, nickname = ?, is_admin = ?, avatar_src = ? WHERE id = ?', [
|
|
email,
|
|
nickname || '',
|
|
isAdmin ? 1 : 0,
|
|
avatarSrc,
|
|
id,
|
|
])
|
|
} else {
|
|
await query('UPDATE users SET email = ?, nickname = ?, is_admin = ? WHERE id = ?', [
|
|
email,
|
|
nickname || '',
|
|
isAdmin ? 1 : 0,
|
|
id,
|
|
])
|
|
}
|
|
return findUserById(id)
|
|
}
|
|
|
|
async function adminUpdateUserPassword({ id, passwordHash }) {
|
|
await query('UPDATE users SET password_hash = ? WHERE id = ?', [passwordHash, id])
|
|
return findUserById(id)
|
|
}
|
|
|
|
async function adminDeleteUser(id) {
|
|
await query('DELETE FROM users WHERE id = ?', [id])
|
|
}
|
|
|
|
async function listTopics(currentUserId = '', options = {}) {
|
|
const includePrivate = !!options.includePrivate
|
|
const rows = await query(
|
|
`
|
|
SELECT id, slug, name, thumbnail_src, tags_json, is_public, display_rank, created_at
|
|
FROM topics
|
|
WHERE id <> ?
|
|
${includePrivate ? '' : 'AND is_public = 1'}
|
|
ORDER BY
|
|
CASE WHEN display_rank IS NULL THEN 1 ELSE 0 END ASC,
|
|
display_rank ASC,
|
|
created_at DESC,
|
|
name ASC
|
|
`,
|
|
[FREEFORM_TOPIC_ID]
|
|
)
|
|
const topics = rows.map(mapTopicRow)
|
|
if (!currentUserId) return topics.map((topic) => ({ ...topic, isFavorited: false }))
|
|
|
|
const favoriteRows = await query('SELECT topic_id FROM favorite_topics WHERE user_id = ?', [currentUserId])
|
|
const favoriteSet = new Set(favoriteRows.map((row) => row.topic_id))
|
|
return topics.map((topic) => ({
|
|
...topic,
|
|
isFavorited: favoriteSet.has(topic.id),
|
|
}))
|
|
}
|
|
|
|
async function findTopicById(id) {
|
|
const rows = await query(
|
|
'SELECT id, slug, name, thumbnail_src, tags_json, is_public, display_rank, created_at FROM topics WHERE id = ? LIMIT 1',
|
|
[id]
|
|
)
|
|
return mapTopicRow(rows[0])
|
|
}
|
|
|
|
async function findTopicBySlug(slug) {
|
|
const normalizedSlug = normalizeTopicSlug(slug)
|
|
if (!normalizedSlug) return null
|
|
const rows = await query(
|
|
'SELECT id, slug, name, thumbnail_src, tags_json, is_public, display_rank, created_at FROM topics WHERE slug = ? LIMIT 1',
|
|
[normalizedSlug]
|
|
)
|
|
return mapTopicRow(rows[0])
|
|
}
|
|
|
|
async function findTopicByIdentifier(topicRef) {
|
|
const rawRef = String(topicRef || '').trim()
|
|
if (!rawRef) return null
|
|
if (rawRef === FREEFORM_TOPIC_ID) return findTopicById(FREEFORM_TOPIC_ID)
|
|
|
|
const rows = await query(
|
|
`
|
|
SELECT id, slug, name, thumbnail_src, tags_json, is_public, display_rank, created_at
|
|
FROM topics
|
|
WHERE id = ? OR slug = ?
|
|
ORDER BY
|
|
CASE WHEN id = ? THEN 0 ELSE 1 END ASC
|
|
LIMIT 1
|
|
`,
|
|
[rawRef, normalizeTopicSlug(rawRef), rawRef]
|
|
)
|
|
return mapTopicRow(rows[0])
|
|
}
|
|
|
|
async function listTopicItems(topicId) {
|
|
const rows = await query(
|
|
`
|
|
SELECT id, topic_id, src, label, tags_json, display_order, created_at
|
|
FROM topic_items
|
|
WHERE topic_id = ?
|
|
ORDER BY
|
|
CASE WHEN display_order IS NULL THEN 1 ELSE 0 END ASC,
|
|
display_order ASC,
|
|
created_at DESC,
|
|
id DESC
|
|
`,
|
|
[topicId]
|
|
)
|
|
return rows.map(mapTopicItemRow)
|
|
}
|
|
|
|
async function findTopicItemById(itemId) {
|
|
const rows = await query('SELECT id, topic_id, src, label, tags_json, display_order, created_at FROM topic_items WHERE id = ? LIMIT 1', [itemId])
|
|
return mapTopicItemRow(rows[0])
|
|
}
|
|
|
|
async function getTopicDetail(topicRef) {
|
|
const topic = await findTopicByIdentifier(topicRef)
|
|
if (!topic) return null
|
|
const items = await listTopicItems(topic.id)
|
|
return { topic, template: topic, items }
|
|
}
|
|
|
|
async function createTopic({ slug, name, tags = [], isPublic = true }) {
|
|
const topicId = nanoid()
|
|
const topicSlug = assertTopicSlug(slug)
|
|
await query('INSERT INTO topics (id, slug, name, thumbnail_src, tags_json, is_public, display_rank, created_at) VALUES (?, ?, ?, ?, ?, ?, ?, ?)', [
|
|
topicId,
|
|
topicSlug,
|
|
name,
|
|
'',
|
|
serializeJson(normalizeTags(tags)),
|
|
isPublic ? 1 : 0,
|
|
null,
|
|
now(),
|
|
])
|
|
return findTopicById(topicId)
|
|
}
|
|
|
|
async function updateTopicMeta(topicId, { slug, name, tags = [], isPublic }) {
|
|
const topicSlug = assertTopicSlug(slug)
|
|
await query('UPDATE topics SET slug = ?, name = ?, tags_json = ?, is_public = ? WHERE id = ?', [
|
|
topicSlug,
|
|
name,
|
|
serializeJson(normalizeTags(tags)),
|
|
isPublic ? 1 : 0,
|
|
topicId,
|
|
])
|
|
return findTopicById(topicId)
|
|
}
|
|
|
|
async function updateTopicThumbnail(topicId, thumbnailSrc) {
|
|
await query('UPDATE topics SET thumbnail_src = ? WHERE id = ?', [thumbnailSrc, topicId])
|
|
return findTopicById(topicId)
|
|
}
|
|
|
|
async function updateTopicVisibility(topicId, isPublic) {
|
|
await query('UPDATE topics SET is_public = ? WHERE id = ?', [isPublic ? 1 : 0, topicId])
|
|
return findTopicById(topicId)
|
|
}
|
|
|
|
async function findImageAssetByHash(contentHash) {
|
|
const rows = await query(
|
|
'SELECT id, content_hash, src, label_override, mime_type, byte_size, original_byte_size, width, height, created_at FROM image_assets WHERE content_hash = ? LIMIT 1',
|
|
[contentHash]
|
|
)
|
|
return mapImageAssetRow(rows[0])
|
|
}
|
|
|
|
async function findImageAssetBySrc(src) {
|
|
const rows = await query(
|
|
'SELECT id, content_hash, src, label_override, mime_type, byte_size, original_byte_size, width, height, created_at FROM image_assets WHERE src = ? LIMIT 1',
|
|
[src]
|
|
)
|
|
return mapImageAssetRow(rows[0])
|
|
}
|
|
|
|
async function createImageAsset({ id, contentHash, src, mimeType = "image/webp", byteSize, originalByteSize, width, height }) {
|
|
const createdAt = now()
|
|
await query(
|
|
'INSERT INTO image_assets (id, content_hash, src, mime_type, byte_size, original_byte_size, width, height, created_at) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)',
|
|
[id, contentHash, src, mimeType, byteSize, originalByteSize, width, height, createdAt]
|
|
)
|
|
return findImageAssetByHash(contentHash)
|
|
}
|
|
|
|
async function createImageOptimizationJob({ id, sourceCategory, targetDirectory, originalByteSize }) {
|
|
const queuedAt = now()
|
|
await query(
|
|
'INSERT INTO image_optimization_jobs (id, status, source_category, target_directory, original_byte_size, optimized_byte_size, reused_asset, error_message, queued_at, started_at, finished_at) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)',
|
|
[id, 'queued', sourceCategory || '', targetDirectory || '', originalByteSize || 0, 0, 0, '', queuedAt, 0, 0]
|
|
)
|
|
return findImageOptimizationJobById(id)
|
|
}
|
|
|
|
async function findImageOptimizationJobById(id) {
|
|
const rows = await query(
|
|
'SELECT id, status, source_category, target_directory, original_byte_size, optimized_byte_size, reused_asset, error_message, queued_at, started_at, finished_at FROM image_optimization_jobs WHERE id = ? LIMIT 1',
|
|
[id]
|
|
)
|
|
return mapImageOptimizationJobRow(rows[0])
|
|
}
|
|
|
|
async function updateImageOptimizationJobStatus({ id, status, optimizedByteSize = 0, reusedAsset = false, errorMessage = '', startedAt, finishedAt }) {
|
|
const fields = ['status = ?', 'optimized_byte_size = ?', 'reused_asset = ?', 'error_message = ?']
|
|
const params = [status, optimizedByteSize, reusedAsset ? 1 : 0, errorMessage.slice(0, 255)]
|
|
|
|
if (typeof startedAt === 'number') {
|
|
fields.push('started_at = ?')
|
|
params.push(startedAt)
|
|
}
|
|
if (typeof finishedAt === 'number') {
|
|
fields.push('finished_at = ?')
|
|
params.push(finishedAt)
|
|
}
|
|
|
|
params.push(id)
|
|
await query(`UPDATE image_optimization_jobs SET ${fields.join(', ')} WHERE id = ?`, params)
|
|
return findImageOptimizationJobById(id)
|
|
}
|
|
|
|
async function listRecentImageOptimizationJobs(limit = 20, { month } = {}) {
|
|
const safeLimit = Math.max(1, Math.min(100, Number(limit) || 20))
|
|
const range = resolveMonthRange(month)
|
|
const where = []
|
|
const params = []
|
|
|
|
if (range) {
|
|
where.push('queued_at >= ? AND queued_at < ?')
|
|
params.push(range.start, range.end)
|
|
}
|
|
|
|
const rows = await query(
|
|
`SELECT id, status, source_category, target_directory, original_byte_size, optimized_byte_size, reused_asset, error_message, queued_at, started_at, finished_at
|
|
FROM image_optimization_jobs
|
|
${where.length ? `WHERE ${where.join(' AND ')}` : ''}
|
|
ORDER BY queued_at DESC
|
|
LIMIT ${safeLimit}`,
|
|
params
|
|
)
|
|
return rows.map(mapImageOptimizationJobRow)
|
|
}
|
|
|
|
async function listUnusedImageAssets({ limit = 100, minAgeHours = 24 } = {}) {
|
|
const safeLimit = Math.max(1, Math.min(500, Number(limit) || 100))
|
|
const safeMinAgeHours = Math.max(0, Number(minAgeHours) || 24)
|
|
const cutoff = now() - safeMinAgeHours * 60 * 60 * 1000
|
|
|
|
const assets = (await query(
|
|
`SELECT id, content_hash, src, label_override, mime_type, byte_size, original_byte_size, width, height, created_at FROM image_assets WHERE created_at <= ? ORDER BY created_at ASC LIMIT ${safeLimit}`,
|
|
[cutoff]
|
|
)).map(mapImageAssetRow)
|
|
|
|
if (!assets.length) return []
|
|
|
|
const referencedSrcs = new Set()
|
|
|
|
const [userRows, topicRows, topicItemRows, customItemRows, tierListRows, templateRequestRows] = await Promise.all([
|
|
query("SELECT avatar_src FROM users WHERE avatar_src <> ''"),
|
|
query("SELECT thumbnail_src FROM topics WHERE thumbnail_src <> ''"),
|
|
query("SELECT src FROM topic_items WHERE src <> ''"),
|
|
query("SELECT src FROM custom_items WHERE src <> ''"),
|
|
query("SELECT thumbnail_src, pool_json FROM tierlists"),
|
|
query("SELECT thumbnail_src_snapshot, items_json, board_items_json FROM template_requests"),
|
|
])
|
|
|
|
for (const row of userRows) if (row.avatar_src) referencedSrcs.add(row.avatar_src)
|
|
for (const row of topicRows) if (row.thumbnail_src) referencedSrcs.add(row.thumbnail_src)
|
|
for (const row of topicItemRows) if (row.src) referencedSrcs.add(row.src)
|
|
for (const row of customItemRows) if (row.src) referencedSrcs.add(row.src)
|
|
|
|
for (const row of tierListRows) {
|
|
if (row.thumbnail_src) referencedSrcs.add(row.thumbnail_src)
|
|
collectUploadSrcsFromItems(parseJson(row.pool_json, []), referencedSrcs)
|
|
}
|
|
|
|
for (const row of templateRequestRows) {
|
|
if (row.thumbnail_src_snapshot) referencedSrcs.add(row.thumbnail_src_snapshot)
|
|
collectUploadSrcsFromItems(parseJson(row.items_json, []), referencedSrcs)
|
|
collectUploadSrcsFromItems(parseJson(row.board_items_json, []), referencedSrcs)
|
|
}
|
|
|
|
return assets.filter((asset) => !referencedSrcs.has(asset.src))
|
|
}
|
|
|
|
async function deleteImageAssets(ids) {
|
|
const uniqueIds = Array.from(new Set((ids || []).filter(Boolean)))
|
|
if (!uniqueIds.length) return []
|
|
const placeholders = uniqueIds.map(() => '?').join(', ')
|
|
const rows = await query(
|
|
`SELECT id, content_hash, src, label_override, mime_type, byte_size, original_byte_size, width, height, created_at FROM image_assets WHERE id IN (${placeholders})`,
|
|
uniqueIds
|
|
)
|
|
await query(`DELETE FROM image_assets WHERE id IN (${placeholders})`, uniqueIds)
|
|
return rows.map(mapImageAssetRow)
|
|
}
|
|
|
|
async function listReferencedUploadSources() {
|
|
const usage = await listReferencedUploadUsage()
|
|
return usage.map((entry) => entry.src)
|
|
}
|
|
|
|
async function listReferencedUploadUsage() {
|
|
const usageMap = new Map()
|
|
const addUsage = (src, role) => {
|
|
if (typeof src !== 'string' || !src.startsWith('/uploads/')) return
|
|
if (!usageMap.has(src)) usageMap.set(src, new Set())
|
|
usageMap.get(src).add(role)
|
|
}
|
|
|
|
const [userRows, topicRows, topicItemRows, customItemRows, tierListRows, templateRequestRows] = await Promise.all([
|
|
query("SELECT avatar_src FROM users WHERE avatar_src <> ''"),
|
|
query("SELECT thumbnail_src FROM topics WHERE thumbnail_src <> ''"),
|
|
query("SELECT src FROM topic_items WHERE src <> ''"),
|
|
query("SELECT src FROM custom_items WHERE src <> ''"),
|
|
query("SELECT id, thumbnail_src, pool_json FROM tierlists"),
|
|
query("SELECT id, thumbnail_src_snapshot, items_json, board_items_json FROM template_requests"),
|
|
])
|
|
|
|
for (const row of userRows) addUsage(row.avatar_src, 'avatar')
|
|
for (const row of topicRows) addUsage(row.thumbnail_src, 'topic-thumbnail')
|
|
for (const row of topicItemRows) addUsage(row.src, 'topic-item')
|
|
for (const row of customItemRows) addUsage(row.src, 'custom-item')
|
|
|
|
for (const row of tierListRows) {
|
|
addUsage(row.thumbnail_src, 'tierlist-thumbnail')
|
|
for (const item of parseJson(row.pool_json, [])) addUsage(item?.src, 'tierlist-pool')
|
|
}
|
|
|
|
for (const row of templateRequestRows) {
|
|
addUsage(row.thumbnail_src_snapshot, 'template-thumbnail')
|
|
for (const item of parseJson(row.items_json, [])) addUsage(item?.src, 'template-item')
|
|
for (const item of parseJson(row.board_items_json, [])) addUsage(item?.src, 'template-board-item')
|
|
}
|
|
|
|
return Array.from(usageMap.entries())
|
|
.map(([src, roles]) => ({ src, roles: Array.from(roles).sort() }))
|
|
.sort((a, b) => a.src.localeCompare(b.src))
|
|
}
|
|
|
|
function replaceItemSrc(items, fromSrc, toSrc, toLabel = '') {
|
|
let changed = false
|
|
const nextItems = (items || []).map((item) => {
|
|
if (item?.src !== fromSrc) return item
|
|
changed = true
|
|
return {
|
|
...item,
|
|
src: toSrc,
|
|
...(typeof toLabel === 'string' && toLabel.trim() ? { label: toLabel.trim().slice(0, 60) } : {}),
|
|
}
|
|
})
|
|
return { changed, items: nextItems }
|
|
}
|
|
|
|
function replaceItemById(items, itemId, nextSrc, nextLabel = '') {
|
|
let changed = false
|
|
const normalizedLabel = typeof nextLabel === 'string' ? nextLabel.trim().slice(0, 60) : ''
|
|
const nextItems = (items || []).map((item) => {
|
|
if (item?.id !== itemId) return item
|
|
changed = true
|
|
return {
|
|
...item,
|
|
...(typeof nextSrc === 'string' && nextSrc ? { src: nextSrc } : {}),
|
|
...(normalizedLabel ? { label: normalizedLabel } : {}),
|
|
}
|
|
})
|
|
return { changed, items: nextItems }
|
|
}
|
|
|
|
async function replaceUploadSourceReferences({ fromSrc, toSrc, toLabel = '', updateCustomItemsBySrc = true }) {
|
|
if (!fromSrc || !toSrc || fromSrc === toSrc) return { updatedRows: 0 }
|
|
const normalizedLabel = typeof toLabel === 'string' ? toLabel.trim().slice(0, 60) : ''
|
|
|
|
const [userResult, topicResult, topicItemResult, customItemResult] = await Promise.all([
|
|
query('UPDATE users SET avatar_src = ? WHERE avatar_src = ?', [toSrc, fromSrc]),
|
|
query('UPDATE topics SET thumbnail_src = ? WHERE thumbnail_src = ?', [toSrc, fromSrc]),
|
|
normalizedLabel
|
|
? query('UPDATE topic_items SET src = ?, label = ? WHERE src = ?', [toSrc, normalizedLabel, fromSrc])
|
|
: query('UPDATE topic_items SET src = ? WHERE src = ?', [toSrc, fromSrc]),
|
|
updateCustomItemsBySrc
|
|
? normalizedLabel
|
|
? query('UPDATE custom_items SET src = ?, label = ? WHERE src = ?', [toSrc, normalizedLabel, fromSrc])
|
|
: query('UPDATE custom_items SET src = ? WHERE src = ?', [toSrc, fromSrc])
|
|
: Promise.resolve({ affectedRows: 0 }),
|
|
])
|
|
|
|
let updatedRows = Number(userResult.affectedRows || 0) + Number(topicResult.affectedRows || 0) + Number(topicItemResult.affectedRows || 0) + Number(customItemResult.affectedRows || 0)
|
|
|
|
const tierListRows = await query('SELECT id, thumbnail_src, pool_json FROM tierlists')
|
|
for (const row of tierListRows) {
|
|
let nextThumbnail = row.thumbnail_src
|
|
let changed = false
|
|
if (row.thumbnail_src === fromSrc) {
|
|
nextThumbnail = toSrc
|
|
changed = true
|
|
}
|
|
|
|
const replacedPool = replaceItemSrc(parseJson(row.pool_json, []), fromSrc, toSrc, normalizedLabel)
|
|
if (replacedPool.changed) changed = true
|
|
|
|
if (changed) {
|
|
await query('UPDATE tierlists SET thumbnail_src = ?, pool_json = ?, updated_at = ? WHERE id = ?', [
|
|
nextThumbnail || '',
|
|
serializeJson(replacedPool.items),
|
|
now(),
|
|
row.id,
|
|
])
|
|
updatedRows += 1
|
|
}
|
|
}
|
|
|
|
const requestRows = await query('SELECT id, thumbnail_src_snapshot, items_json, board_items_json FROM template_requests')
|
|
for (const row of requestRows) {
|
|
let nextThumbnail = row.thumbnail_src_snapshot
|
|
let changed = false
|
|
if (row.thumbnail_src_snapshot === fromSrc) {
|
|
nextThumbnail = toSrc
|
|
changed = true
|
|
}
|
|
|
|
const replacedItems = replaceItemSrc(parseJson(row.items_json, []), fromSrc, toSrc, normalizedLabel)
|
|
const replacedBoardItems = replaceItemSrc(parseJson(row.board_items_json, []), fromSrc, toSrc, normalizedLabel)
|
|
if (replacedItems.changed || replacedBoardItems.changed) changed = true
|
|
|
|
if (changed) {
|
|
await query('UPDATE template_requests SET thumbnail_src_snapshot = ?, items_json = ?, board_items_json = ?, updated_at = ? WHERE id = ?', [
|
|
nextThumbnail || '',
|
|
serializeJson(replacedItems.items),
|
|
serializeJson(replacedBoardItems.items),
|
|
now(),
|
|
row.id,
|
|
])
|
|
updatedRows += 1
|
|
}
|
|
}
|
|
|
|
return { updatedRows }
|
|
}
|
|
|
|
async function updateCustomItemDisplayReferences({ itemId, src = '', label = '' }) {
|
|
if (!itemId) return { updatedRows: 0 }
|
|
const normalizedLabel = typeof label === 'string' ? label.trim().slice(0, 60) : ''
|
|
let updatedRows = 0
|
|
|
|
const tierListRows = await query('SELECT id, pool_json FROM tierlists')
|
|
for (const row of tierListRows) {
|
|
const replacedPool = replaceItemById(parseJson(row.pool_json, []), itemId, src, normalizedLabel)
|
|
if (!replacedPool.changed) continue
|
|
await query('UPDATE tierlists SET pool_json = ?, updated_at = ? WHERE id = ?', [
|
|
serializeJson(replacedPool.items),
|
|
now(),
|
|
row.id,
|
|
])
|
|
updatedRows += 1
|
|
}
|
|
|
|
const requestRows = await query('SELECT id, items_json, board_items_json FROM template_requests')
|
|
for (const row of requestRows) {
|
|
const replacedItems = replaceItemById(parseJson(row.items_json, []), itemId, src, normalizedLabel)
|
|
const replacedBoardItems = replaceItemById(parseJson(row.board_items_json, []), itemId, src, normalizedLabel)
|
|
if (!replacedItems.changed && !replacedBoardItems.changed) continue
|
|
await query('UPDATE template_requests SET items_json = ?, board_items_json = ?, updated_at = ? WHERE id = ?', [
|
|
serializeJson(replacedItems.items),
|
|
serializeJson(replacedBoardItems.items),
|
|
now(),
|
|
row.id,
|
|
])
|
|
updatedRows += 1
|
|
}
|
|
|
|
return { updatedRows }
|
|
}
|
|
|
|
async function listImageAssets() {
|
|
const rows = await query(
|
|
'SELECT id, content_hash, src, label_override, mime_type, byte_size, original_byte_size, width, height, created_at FROM image_assets ORDER BY created_at DESC'
|
|
)
|
|
return rows.map(mapImageAssetRow)
|
|
}
|
|
|
|
async function findImageAssetById(id) {
|
|
const rows = await query(
|
|
'SELECT id, content_hash, src, label_override, mime_type, byte_size, original_byte_size, width, height, created_at FROM image_assets WHERE id = ? LIMIT 1',
|
|
[id]
|
|
)
|
|
return mapImageAssetRow(rows[0])
|
|
}
|
|
|
|
async function updateImageAssetSrc({ fromSrc, toSrc }) {
|
|
if (!fromSrc || !toSrc || fromSrc === toSrc) return null
|
|
await query('UPDATE image_assets SET src = ? WHERE src = ?', [toSrc, fromSrc])
|
|
return findImageAssetBySrc(toSrc)
|
|
}
|
|
|
|
async function getReferencedUploadFootprint() {
|
|
const [referencedSrcs, assets] = await Promise.all([listReferencedUploadSources(), listImageAssets()])
|
|
const assetMap = new Map(assets.map((asset) => [asset.src, asset]))
|
|
let totalReferencedByteSize = 0
|
|
let trackedReferencedByteSize = 0
|
|
let legacyReferencedByteSize = 0
|
|
let trackedReferencedCount = 0
|
|
let legacyReferencedCount = 0
|
|
let missingCount = 0
|
|
|
|
for (const src of referencedSrcs) {
|
|
if (typeof src !== 'string' || !src.startsWith('/uploads/')) continue
|
|
const absolutePath = path.join(__dirname, '..', src.replace(/^\//, ''))
|
|
|
|
try {
|
|
const stat = await fs.stat(absolutePath)
|
|
const size = Number(stat.size || 0)
|
|
totalReferencedByteSize += size
|
|
if (assetMap.has(src)) {
|
|
trackedReferencedCount += 1
|
|
trackedReferencedByteSize += size
|
|
} else {
|
|
legacyReferencedCount += 1
|
|
legacyReferencedByteSize += size
|
|
}
|
|
} catch (error) {
|
|
if (error?.code === 'ENOENT') missingCount += 1
|
|
}
|
|
}
|
|
|
|
return {
|
|
referencedCount: referencedSrcs.length,
|
|
totalReferencedByteSize,
|
|
trackedReferencedCount,
|
|
trackedReferencedByteSize,
|
|
legacyReferencedCount,
|
|
legacyReferencedByteSize,
|
|
missingCount,
|
|
}
|
|
}
|
|
|
|
async function fileExistsForUploadSrc(src) {
|
|
if (typeof src !== 'string' || !src.startsWith('/uploads/')) return true
|
|
const absolutePath = path.join(__dirname, '..', src.replace(/^\//, ''))
|
|
try {
|
|
await fs.stat(absolutePath)
|
|
return true
|
|
} catch (error) {
|
|
if (error?.code === 'ENOENT') return false
|
|
throw error
|
|
}
|
|
}
|
|
|
|
function stripItemIdsFromGroups(groups, missingItemIds) {
|
|
let changed = false
|
|
const nextGroups = (groups || []).map((group) => {
|
|
const nextItemIds = (group?.itemIds || []).filter((itemId) => !missingItemIds.has(itemId))
|
|
if (nextItemIds.length !== (group?.itemIds || []).length) changed = true
|
|
return {
|
|
...group,
|
|
itemIds: nextItemIds,
|
|
}
|
|
})
|
|
return { changed, groups: nextGroups }
|
|
}
|
|
|
|
function stripMissingItems(items, missingItemIds, missingSrcs) {
|
|
let changed = false
|
|
const nextItems = (items || []).filter((item) => {
|
|
const shouldRemove =
|
|
(item?.id && missingItemIds.has(item.id)) ||
|
|
(typeof item?.src === 'string' && missingSrcs.has(item.src))
|
|
if (shouldRemove) changed = true
|
|
return !shouldRemove
|
|
})
|
|
return { changed, items: nextItems }
|
|
}
|
|
|
|
async function cleanupMissingUploadReferences() {
|
|
const stats = {
|
|
clearedAvatars: 0,
|
|
clearedTopicThumbnails: 0,
|
|
clearedTierListThumbnails: 0,
|
|
clearedTemplateRequestThumbnails: 0,
|
|
deletedTopicItems: 0,
|
|
updatedTierLists: 0,
|
|
updatedTemplateRequests: 0,
|
|
deletedCustomItems: 0,
|
|
}
|
|
|
|
const [userRows, topicRows, topicItemRows, customItemRows, tierListRows, templateRequestRows] = await Promise.all([
|
|
query("SELECT id, avatar_src FROM users WHERE avatar_src <> ''"),
|
|
query("SELECT id, thumbnail_src FROM topics WHERE thumbnail_src <> ''"),
|
|
query("SELECT id, src FROM topic_items WHERE src <> ''"),
|
|
query("SELECT id, src FROM custom_items WHERE src <> ''"),
|
|
query("SELECT id, thumbnail_src, groups_json, pool_json FROM tierlists"),
|
|
query("SELECT id, thumbnail_src_snapshot, groups_json, items_json, board_items_json FROM template_requests"),
|
|
])
|
|
|
|
for (const row of userRows) {
|
|
if (await fileExistsForUploadSrc(row.avatar_src)) continue
|
|
await query('UPDATE users SET avatar_src = ? WHERE id = ?', ['', row.id])
|
|
stats.clearedAvatars += 1
|
|
}
|
|
|
|
for (const row of topicRows) {
|
|
if (await fileExistsForUploadSrc(row.thumbnail_src)) continue
|
|
await query('UPDATE topics SET thumbnail_src = ? WHERE id = ?', ['', row.id])
|
|
stats.clearedTopicThumbnails += 1
|
|
}
|
|
|
|
for (const row of topicItemRows) {
|
|
if (await fileExistsForUploadSrc(row.src)) continue
|
|
await deleteTopicItem(row.id)
|
|
stats.deletedTopicItems += 1
|
|
}
|
|
|
|
const missingCustomItemIds = new Set()
|
|
const missingCustomSrcs = new Set()
|
|
for (const row of customItemRows) {
|
|
if (await fileExistsForUploadSrc(row.src)) continue
|
|
missingCustomItemIds.add(row.id)
|
|
missingCustomSrcs.add(row.src)
|
|
}
|
|
|
|
for (const row of tierListRows) {
|
|
const groups = parseJson(row.groups_json, [])
|
|
const pool = parseJson(row.pool_json, [])
|
|
let changed = false
|
|
let nextThumbnail = row.thumbnail_src || ''
|
|
|
|
if (row.thumbnail_src && !(await fileExistsForUploadSrc(row.thumbnail_src))) {
|
|
nextThumbnail = ''
|
|
changed = true
|
|
stats.clearedTierListThumbnails += 1
|
|
}
|
|
|
|
const strippedPool = stripMissingItems(pool, missingCustomItemIds, missingCustomSrcs)
|
|
const strippedGroups = stripItemIdsFromGroups(groups, missingCustomItemIds)
|
|
if (strippedPool.changed || strippedGroups.changed) changed = true
|
|
|
|
if (changed) {
|
|
await query('UPDATE tierlists SET thumbnail_src = ?, groups_json = ?, pool_json = ?, updated_at = ? WHERE id = ?', [
|
|
nextThumbnail,
|
|
serializeJson(strippedGroups.groups),
|
|
serializeJson(strippedPool.items),
|
|
now(),
|
|
row.id,
|
|
])
|
|
stats.updatedTierLists += 1
|
|
}
|
|
}
|
|
|
|
for (const row of templateRequestRows) {
|
|
const groups = parseJson(row.groups_json, [])
|
|
const items = parseJson(row.items_json, [])
|
|
const boardItems = parseJson(row.board_items_json, [])
|
|
let changed = false
|
|
let nextThumbnail = row.thumbnail_src_snapshot || ''
|
|
|
|
if (row.thumbnail_src_snapshot && !(await fileExistsForUploadSrc(row.thumbnail_src_snapshot))) {
|
|
nextThumbnail = ''
|
|
changed = true
|
|
stats.clearedTemplateRequestThumbnails += 1
|
|
}
|
|
|
|
const strippedItems = stripMissingItems(items, missingCustomItemIds, missingCustomSrcs)
|
|
const strippedBoardItems = stripMissingItems(boardItems, missingCustomItemIds, missingCustomSrcs)
|
|
const strippedGroups = stripItemIdsFromGroups(groups, missingCustomItemIds)
|
|
if (strippedItems.changed || strippedBoardItems.changed || strippedGroups.changed) changed = true
|
|
|
|
if (changed) {
|
|
await query(
|
|
'UPDATE template_requests SET thumbnail_src_snapshot = ?, groups_json = ?, items_json = ?, board_items_json = ?, updated_at = ? WHERE id = ?',
|
|
[
|
|
nextThumbnail,
|
|
serializeJson(strippedGroups.groups),
|
|
serializeJson(strippedItems.items),
|
|
serializeJson(strippedBoardItems.items),
|
|
now(),
|
|
row.id,
|
|
]
|
|
)
|
|
stats.updatedTemplateRequests += 1
|
|
}
|
|
}
|
|
|
|
if (missingCustomItemIds.size) {
|
|
await deleteCustomItems(Array.from(missingCustomItemIds))
|
|
stats.deletedCustomItems = missingCustomItemIds.size
|
|
}
|
|
|
|
return stats
|
|
}
|
|
|
|
async function getImageAssetStats({ month } = {}) {
|
|
const range = resolveMonthRange(month)
|
|
const jobWhere = []
|
|
const jobParams = []
|
|
|
|
if (range) {
|
|
jobWhere.push('queued_at >= ? AND queued_at < ?')
|
|
jobParams.push(range.start, range.end)
|
|
}
|
|
|
|
const [assetRows, jobRows, footprint] = await Promise.all([
|
|
query(
|
|
`SELECT COUNT(*) AS asset_count, COALESCE(SUM(byte_size), 0) AS total_byte_size, COALESCE(SUM(original_byte_size), 0) AS total_original_byte_size FROM image_assets`
|
|
),
|
|
query(
|
|
`SELECT
|
|
COALESCE(SUM(CASE WHEN status = 'queued' THEN 1 ELSE 0 END), 0) AS queued_count,
|
|
COALESCE(SUM(CASE WHEN status = 'processing' THEN 1 ELSE 0 END), 0) AS processing_count,
|
|
COALESCE(SUM(CASE WHEN status = 'completed' THEN 1 ELSE 0 END), 0) AS completed_count,
|
|
COALESCE(SUM(CASE WHEN status = 'failed' THEN 1 ELSE 0 END), 0) AS failed_count,
|
|
COALESCE(SUM(CASE WHEN status = 'completed' AND reused_asset = 1 THEN 1 ELSE 0 END), 0) AS reused_count
|
|
FROM image_optimization_jobs
|
|
${jobWhere.length ? `WHERE ${jobWhere.join(' AND ')}` : ''}`,
|
|
jobParams
|
|
),
|
|
getReferencedUploadFootprint(),
|
|
])
|
|
|
|
const asset = assetRows[0] || {}
|
|
const jobs = jobRows[0] || {}
|
|
const totalByteSize = Number(asset.total_byte_size || 0)
|
|
const totalOriginalByteSize = Number(asset.total_original_byte_size || 0)
|
|
const savedByteSize = Math.max(0, totalOriginalByteSize - totalByteSize)
|
|
|
|
return {
|
|
assetCount: Number(asset.asset_count || 0),
|
|
totalByteSize,
|
|
totalOriginalByteSize,
|
|
savedByteSize,
|
|
savingsRatio: totalOriginalByteSize > 0 ? savedByteSize / totalOriginalByteSize : 0,
|
|
referencedCount: Number(footprint.referencedCount || 0),
|
|
referencedByteSize: Number(footprint.totalReferencedByteSize || 0),
|
|
trackedReferencedCount: Number(footprint.trackedReferencedCount || 0),
|
|
trackedReferencedByteSize: Number(footprint.trackedReferencedByteSize || 0),
|
|
legacyReferencedCount: Number(footprint.legacyReferencedCount || 0),
|
|
legacyReferencedByteSize: Number(footprint.legacyReferencedByteSize || 0),
|
|
missingReferencedCount: Number(footprint.missingCount || 0),
|
|
queuedCount: Number(jobs.queued_count || 0),
|
|
processingCount: Number(jobs.processing_count || 0),
|
|
completedCount: Number(jobs.completed_count || 0),
|
|
failedCount: Number(jobs.failed_count || 0),
|
|
reusedCount: Number(jobs.reused_count || 0),
|
|
}
|
|
}
|
|
|
|
async function clearImageOptimizationJobs({ month } = {}) {
|
|
const range = resolveMonthRange(month)
|
|
if (range) {
|
|
const result = await query('DELETE FROM image_optimization_jobs WHERE queued_at >= ? AND queued_at < ?', [range.start, range.end])
|
|
return Number(result.affectedRows || 0)
|
|
}
|
|
|
|
const result = await query('DELETE FROM image_optimization_jobs')
|
|
return Number(result.affectedRows || 0)
|
|
}
|
|
async function createTopicItem({ id, topicId, src, label, tags = [] }) {
|
|
const createdAt = now()
|
|
const minOrderRows = await query('SELECT MIN(display_order) AS min_display_order FROM topic_items WHERE topic_id = ?', [topicId])
|
|
const nextDisplayOrder =
|
|
minOrderRows[0]?.min_display_order == null ? 0 : Number(minOrderRows[0].min_display_order) - 1
|
|
await query('INSERT INTO topic_items (id, topic_id, src, label, tags_json, display_order, created_at) VALUES (?, ?, ?, ?, ?, ?, ?)', [
|
|
id,
|
|
topicId,
|
|
src,
|
|
label,
|
|
serializeJson(normalizeTags(tags)),
|
|
nextDisplayOrder,
|
|
createdAt,
|
|
])
|
|
const rows = await query('SELECT id, topic_id, src, label, tags_json, display_order, created_at FROM topic_items WHERE id = ? LIMIT 1', [id])
|
|
return mapTopicItemRow(rows[0])
|
|
}
|
|
|
|
async function updateTopicItemLabel(itemId, label) {
|
|
await query('UPDATE topic_items SET label = ? WHERE id = ?', [label, itemId])
|
|
const rows = await query('SELECT id, topic_id, src, label, tags_json, display_order, created_at FROM topic_items WHERE id = ? LIMIT 1', [itemId])
|
|
return mapTopicItemRow(rows[0])
|
|
}
|
|
|
|
async function updateTopicItemMeta(itemId, { label, tags = [] }) {
|
|
await query('UPDATE topic_items SET label = ?, tags_json = ? WHERE id = ?', [
|
|
label,
|
|
serializeJson(normalizeTags(tags)),
|
|
itemId,
|
|
])
|
|
const rows = await query('SELECT id, topic_id, src, label, tags_json, display_order, created_at FROM topic_items WHERE id = ? LIMIT 1', [itemId])
|
|
return mapTopicItemRow(rows[0])
|
|
}
|
|
|
|
async function updateTopicItemDisplayOrder(topicId, itemIds) {
|
|
const normalizedIds = Array.from(new Set((itemIds || []).filter(Boolean)))
|
|
const existingItems = await listTopicItems(topicId)
|
|
const existingIdSet = new Set(existingItems.map((item) => item.id))
|
|
const orderedIds = normalizedIds.filter((id) => existingIdSet.has(id))
|
|
const remainingIds = existingItems.map((item) => item.id).filter((id) => !orderedIds.includes(id))
|
|
const finalIds = [...orderedIds, ...remainingIds]
|
|
|
|
await Promise.all(
|
|
finalIds.map((itemId, index) => query('UPDATE topic_items SET display_order = ? WHERE id = ? AND topic_id = ?', [index + 1, itemId, topicId]))
|
|
)
|
|
|
|
return listTopicItems(topicId)
|
|
}
|
|
|
|
async function updateCustomItemLabel(itemId, label) {
|
|
await query('UPDATE custom_items SET label = ? WHERE id = ?', [label, itemId])
|
|
const rows = await query(`
|
|
SELECT c.id, c.owner_id, c.src, c.label, c.tags_json, c.replaced_by_item_id, c.replaced_by_src, c.replaced_by_label, c.replaced_at, c.created_at, u.nickname, u.email
|
|
FROM custom_items c
|
|
INNER JOIN users u ON u.id = c.owner_id
|
|
WHERE c.id = ?
|
|
LIMIT 1
|
|
`, [itemId])
|
|
const row = rows[0]
|
|
if (!row) return null
|
|
return {
|
|
...mapCustomItemRow(row),
|
|
ownerName: row.nickname || row.email,
|
|
ownerEmail: row.email,
|
|
}
|
|
}
|
|
|
|
async function updateCustomItemMeta(itemId, { label, tags = [] }) {
|
|
await query('UPDATE custom_items SET label = ?, tags_json = ? WHERE id = ?', [
|
|
label,
|
|
serializeJson(normalizeTags(tags)),
|
|
itemId,
|
|
])
|
|
const rows = await query(`
|
|
SELECT c.id, c.owner_id, c.src, c.label, c.tags_json, c.replaced_by_item_id, c.replaced_by_src, c.replaced_by_label, c.replaced_at, c.created_at, u.nickname, u.email
|
|
FROM custom_items c
|
|
INNER JOIN users u ON u.id = c.owner_id
|
|
WHERE c.id = ?
|
|
LIMIT 1
|
|
`, [itemId])
|
|
const row = rows[0]
|
|
if (!row) return null
|
|
return {
|
|
...mapCustomItemRow(row),
|
|
ownerName: row.nickname || row.email,
|
|
ownerEmail: row.email,
|
|
}
|
|
}
|
|
|
|
async function markCustomItemReplaced({ itemId, replacedByItemId = '', replacedBySrc = '', replacedByLabel = '' }) {
|
|
await query(
|
|
'UPDATE custom_items SET replaced_by_item_id = ?, replaced_by_src = ?, replaced_by_label = ?, replaced_at = ? WHERE id = ?',
|
|
[replacedByItemId || '', replacedBySrc || '', replacedByLabel || '', now(), itemId]
|
|
)
|
|
return findCustomItemById(itemId)
|
|
}
|
|
|
|
async function clearCustomItemReplacement(itemId) {
|
|
await query(
|
|
'UPDATE custom_items SET replaced_by_item_id = ?, replaced_by_src = ?, replaced_by_label = ?, replaced_at = 0 WHERE id = ?',
|
|
['', '', '', itemId]
|
|
)
|
|
return findCustomItemById(itemId)
|
|
}
|
|
|
|
async function updateImageAssetLabel(assetId, label) {
|
|
await query('UPDATE image_assets SET label_override = ? WHERE id = ?', [label, assetId])
|
|
const rows = await query('SELECT id, content_hash, src, label_override, mime_type, byte_size, original_byte_size, width, height, created_at FROM image_assets WHERE id = ? LIMIT 1', [assetId])
|
|
return mapImageAssetRow(rows[0])
|
|
}
|
|
|
|
async function countTierListsUsingTopicItem(itemId) {
|
|
if (!itemId) return { totalCount: 0, publicCount: 0, privateCount: 0 }
|
|
|
|
const rows = await query(
|
|
`
|
|
SELECT id, is_public, groups_json
|
|
FROM tierlists
|
|
`
|
|
)
|
|
|
|
let totalCount = 0
|
|
let publicCount = 0
|
|
let privateCount = 0
|
|
|
|
rows.forEach((row) => {
|
|
const groups = parseJson(row.groups_json, [])
|
|
const inGroups = groups.some((group) => (group?.itemIds || []).includes(itemId))
|
|
if (!inGroups) return
|
|
totalCount += 1
|
|
if (row.is_public) publicCount += 1
|
|
else privateCount += 1
|
|
})
|
|
|
|
return { totalCount, publicCount, privateCount }
|
|
}
|
|
|
|
async function deleteTopicItem(itemId) {
|
|
await query('DELETE FROM topic_items WHERE id = ?', [itemId])
|
|
}
|
|
|
|
async function deleteTopic(topicId) {
|
|
await query('DELETE FROM topics WHERE id = ?', [topicId])
|
|
}
|
|
|
|
async function updateTopicDisplayOrder(topicIds) {
|
|
const normalizedIds = Array.from(new Set((topicIds || []).filter((id) => id && id !== FREEFORM_TOPIC_ID))).slice(0, 50)
|
|
|
|
await query('UPDATE topics SET display_rank = NULL WHERE id <> ?', [FREEFORM_TOPIC_ID])
|
|
|
|
await Promise.all(
|
|
normalizedIds.map((topicId, index) =>
|
|
query('UPDATE topics SET display_rank = ? WHERE id = ? AND id <> ?', [index + 1, topicId, FREEFORM_TOPIC_ID])
|
|
)
|
|
)
|
|
|
|
return listTopics()
|
|
}
|
|
|
|
async function createCustomItem({ id, ownerId, src, label, tags = [] }) {
|
|
const createdAt = now()
|
|
await query('INSERT INTO custom_items (id, owner_id, src, label, tags_json, created_at) VALUES (?, ?, ?, ?, ?, ?)', [
|
|
id,
|
|
ownerId,
|
|
src,
|
|
label,
|
|
serializeJson(normalizeTags(tags)),
|
|
createdAt,
|
|
])
|
|
return { id, ownerId, src, label, tags: normalizeTags(tags), origin: 'custom', createdAt }
|
|
}
|
|
|
|
async function syncOwnedCustomItemLabels({ ownerId, items }) {
|
|
const customItems = Array.from(
|
|
new Map(
|
|
(items || [])
|
|
.filter((item) => item?.origin === 'custom' && item?.id && typeof item.label === 'string')
|
|
.map((item) => [item.id, item])
|
|
).values()
|
|
)
|
|
|
|
if (!customItems.length) return
|
|
|
|
await Promise.all(
|
|
customItems.map((item) =>
|
|
query('UPDATE custom_items SET label = ? WHERE id = ? AND owner_id = ?', [item.label.trim().slice(0, 60), item.id, ownerId])
|
|
)
|
|
)
|
|
}
|
|
|
|
async function findCustomItemById(id) {
|
|
const rows = await query(
|
|
`
|
|
SELECT id, owner_id, src, label, tags_json, replaced_by_item_id, replaced_by_src, replaced_by_label, replaced_at, created_at
|
|
FROM custom_items
|
|
WHERE id = ?
|
|
LIMIT 1
|
|
`,
|
|
[id]
|
|
)
|
|
|
|
const row = rows[0]
|
|
return mapCustomItemRow(row)
|
|
}
|
|
|
|
async function getCustomItemUsageMeta() {
|
|
const rows = await query(
|
|
`
|
|
SELECT t.topic_id, tp.name AS topic_name, t.groups_json
|
|
FROM tierlists t
|
|
LEFT JOIN topics tp ON tp.id = t.topic_id
|
|
`
|
|
)
|
|
const usageMap = new Map()
|
|
const linkedTemplatesMap = new Map()
|
|
|
|
rows.forEach((row) => {
|
|
const groups = parseJson(row.groups_json, [])
|
|
const seenItemIds = new Set()
|
|
|
|
groups.forEach((group) => {
|
|
;(group?.itemIds || []).forEach((itemId) => {
|
|
usageMap.set(itemId, (usageMap.get(itemId) || 0) + 1)
|
|
if (itemId) seenItemIds.add(itemId)
|
|
})
|
|
})
|
|
|
|
if (!row.topic_id) return
|
|
|
|
seenItemIds.forEach((itemId) => {
|
|
if (!linkedTemplatesMap.has(itemId)) linkedTemplatesMap.set(itemId, new Map())
|
|
linkedTemplatesMap.get(itemId).set(row.topic_id, {
|
|
id: row.topic_id,
|
|
name: row.topic_name || row.topic_id,
|
|
})
|
|
})
|
|
})
|
|
|
|
return {
|
|
usageMap,
|
|
linkedTemplatesMap: new Map(Array.from(linkedTemplatesMap.entries()).map(([itemId, templateMap]) => [itemId, Array.from(templateMap.values())])),
|
|
}
|
|
}
|
|
|
|
async function listCustomItems({ queryText = '', page = 1, limit = 50, filterMode = 'all', collapseShared = false } = {}) {
|
|
const normalizedLimit = Math.min(Math.max(Number(limit) || 50, 1), 200)
|
|
const normalizedPage = Math.max(Number(page) || 1, 1)
|
|
const searchText = (queryText || '').trim()
|
|
const hasQuery = !!searchText
|
|
const search = `%${searchText}%`
|
|
|
|
const [customRows, topicItemRows, assetRows, usageMeta] = await Promise.all([
|
|
query(
|
|
`
|
|
SELECT
|
|
c.id,
|
|
c.owner_id,
|
|
c.src,
|
|
c.label,
|
|
c.tags_json,
|
|
c.replaced_by_item_id,
|
|
c.replaced_by_src,
|
|
c.replaced_by_label,
|
|
c.replaced_at,
|
|
c.created_at,
|
|
u.nickname,
|
|
u.email
|
|
FROM custom_items c
|
|
INNER JOIN users u ON u.id = c.owner_id
|
|
${hasQuery ? 'WHERE c.label LIKE ? OR c.src LIKE ? OR c.tags_json LIKE ? OR u.email LIKE ? OR u.nickname LIKE ?' : ''}
|
|
ORDER BY c.created_at DESC
|
|
`,
|
|
hasQuery ? [search, search, search, search, search] : []
|
|
),
|
|
query(
|
|
`
|
|
SELECT
|
|
gi.id,
|
|
gi.topic_id,
|
|
gi.src,
|
|
gi.label,
|
|
gi.tags_json,
|
|
gi.created_at,
|
|
tp.name AS topic_name
|
|
FROM topic_items gi
|
|
INNER JOIN topics tp ON tp.id = gi.topic_id
|
|
${hasQuery ? 'WHERE gi.label LIKE ? OR gi.src LIKE ? OR gi.tags_json LIKE ? OR gi.topic_id LIKE ? OR tp.name LIKE ?' : ''}
|
|
ORDER BY gi.created_at DESC
|
|
`,
|
|
hasQuery ? [search, search, search, search, search] : []
|
|
),
|
|
query(
|
|
`
|
|
SELECT ia.id, ia.src, ia.label_override, ia.created_at
|
|
FROM image_assets ia
|
|
WHERE ia.src LIKE '/uploads/assets/%'
|
|
${hasQuery ? 'AND ia.src LIKE ?' : ''}
|
|
ORDER BY ia.created_at DESC
|
|
`,
|
|
hasQuery ? [search] : []
|
|
),
|
|
getCustomItemUsageMeta(),
|
|
])
|
|
|
|
const [userAvatarRows, topicThumbnailRows, tierListThumbnailRows, templateRequestThumbnailRows] = await Promise.all([
|
|
query("SELECT avatar_src AS src FROM users WHERE avatar_src <> ''"),
|
|
query("SELECT thumbnail_src AS src FROM topics WHERE thumbnail_src <> ''"),
|
|
query("SELECT thumbnail_src AS src FROM tierlists WHERE thumbnail_src <> ''"),
|
|
query("SELECT thumbnail_src_snapshot AS src FROM template_requests WHERE thumbnail_src_snapshot <> ''"),
|
|
])
|
|
|
|
const avatarSrcSet = new Set(userAvatarRows.map((row) => row.src).filter(Boolean))
|
|
const thumbnailSrcSet = new Set([
|
|
...topicThumbnailRows.map((row) => row.src).filter(Boolean),
|
|
...tierListThumbnailRows.map((row) => row.src).filter(Boolean),
|
|
...templateRequestThumbnailRows.map((row) => row.src).filter(Boolean),
|
|
])
|
|
|
|
const resolveLibraryAssetKind = (src) => {
|
|
if (avatarSrcSet.has(src)) return 'avatar'
|
|
if (thumbnailSrcSet.has(src)) return 'thumbnail'
|
|
return getAssetLibraryKind(src)
|
|
}
|
|
|
|
const resolveLibraryAssetLabel = (src) => {
|
|
if (avatarSrcSet.has(src)) return '프로필 아바타'
|
|
if (thumbnailSrcSet.has(src)) return '썸네일 이미지'
|
|
return getAssetLibrarySourceLabel(src)
|
|
}
|
|
|
|
const templateLinkedBySrc = new Map()
|
|
topicItemRows.forEach((row) => {
|
|
if (!row?.src) return
|
|
if (!templateLinkedBySrc.has(row.src)) templateLinkedBySrc.set(row.src, new Map())
|
|
templateLinkedBySrc.get(row.src).set(row.topic_id, {
|
|
id: row.topic_id,
|
|
name: row.topic_name || row.topic_id,
|
|
})
|
|
})
|
|
|
|
const customItems = customRows.map((row) => {
|
|
const linkedTemplates = Array.from((templateLinkedBySrc.get(row.src) || new Map()).values())
|
|
return {
|
|
id: row.id,
|
|
...mapCustomItemRow(row),
|
|
ownerName: row.nickname || row.email,
|
|
ownerEmail: row.email,
|
|
usageCount: usageMeta.usageMap.get(row.id) || 0,
|
|
linkedTemplates,
|
|
assetKind: resolveLibraryAssetKind(row.src),
|
|
sourceType: 'user',
|
|
sourceLabel: Number(row.replaced_at || 0) > 0 ? '대체된 사용자 아이템' : '사용자 아이템',
|
|
canDelete: true,
|
|
}
|
|
})
|
|
|
|
const templateSrcSet = new Set(topicItemRows.map((row) => row.src).filter(Boolean))
|
|
const customSrcSet = new Set(customRows.map((row) => row.src).filter(Boolean))
|
|
const assetLibraryItems = assetRows
|
|
.filter((row) => {
|
|
if (!row?.src) return false
|
|
if (avatarSrcSet.has(row.src) || thumbnailSrcSet.has(row.src)) return true
|
|
return !templateSrcSet.has(row.src) && !customSrcSet.has(row.src)
|
|
})
|
|
.map((row) => ({
|
|
id: `asset:${row.id}`,
|
|
assetId: row.id,
|
|
ownerId: '',
|
|
src: row.src,
|
|
label: row.label_override || (row.src.split('/').pop() || '').replace(/\.[^.]+$/, '') || '이름 없음',
|
|
tags: [],
|
|
createdAt: Number(row.created_at || 0),
|
|
ownerName: '관리자 미사용 이미지',
|
|
ownerEmail: '',
|
|
usageCount: 0,
|
|
linkedTemplates: [],
|
|
sourceType: 'asset',
|
|
sourceLabel: resolveLibraryAssetLabel(row.src),
|
|
assetKind: resolveLibraryAssetKind(row.src),
|
|
canDelete: true,
|
|
sourceTopicId: '',
|
|
sourceTopicName: '',
|
|
isAssetLibraryItem: true,
|
|
}))
|
|
|
|
const templateItems = topicItemRows.map((row) => ({
|
|
id: row.id,
|
|
ownerId: '',
|
|
src: row.src,
|
|
label: row.label,
|
|
tags: normalizeTags(parseJson(row.tags_json, [])),
|
|
createdAt: Number(row.created_at),
|
|
ownerName: row.topic_name || row.topic_id,
|
|
ownerEmail: '',
|
|
usageCount: usageMeta.usageMap.get(row.id) || 0,
|
|
linkedTemplates: Array.from((templateLinkedBySrc.get(row.src) || new Map()).values()),
|
|
assetKind: resolveLibraryAssetKind(row.src),
|
|
sourceType: 'template',
|
|
sourceLabel: '템플릿 아이템',
|
|
canDelete: true,
|
|
sourceTopicId: row.topic_id,
|
|
sourceTopicName: row.topic_name || row.topic_id,
|
|
}))
|
|
|
|
const baseItems = [...customItems, ...templateItems, ...assetLibraryItems]
|
|
const groupedBySrc = new Map()
|
|
for (const item of baseItems) {
|
|
if (!item?.src) continue
|
|
if (!groupedBySrc.has(item.src)) groupedBySrc.set(item.src, [])
|
|
groupedBySrc.get(item.src).push(item)
|
|
}
|
|
|
|
const allItems = baseItems
|
|
.map((item) => {
|
|
const siblings = groupedBySrc.get(item.src) || [item]
|
|
const linkedTemplates = new Map()
|
|
let userReferenceCount = 0
|
|
let templateReferenceCount = 0
|
|
let assetReferenceCount = 0
|
|
|
|
siblings.forEach((entry) => {
|
|
if (entry.sourceType === 'user') userReferenceCount += 1
|
|
else if (entry.sourceType === 'asset' || entry.isAssetLibraryItem) assetReferenceCount += 1
|
|
else templateReferenceCount += 1
|
|
;(entry.linkedTemplates || []).forEach((template) => {
|
|
if (template?.id) linkedTemplates.set(template.id, template)
|
|
})
|
|
})
|
|
|
|
return {
|
|
...item,
|
|
sharedReferenceCount: siblings.length,
|
|
sharedUserReferenceCount: userReferenceCount,
|
|
sharedTemplateReferenceCount: templateReferenceCount,
|
|
sharedAssetReferenceCount: assetReferenceCount,
|
|
sharedLinkedTemplateCount: linkedTemplates.size,
|
|
sharedEntries: siblings
|
|
.slice()
|
|
.sort((a, b) => Number(b.createdAt || 0) - Number(a.createdAt || 0))
|
|
.map((entry) => ({
|
|
id: entry.id,
|
|
label: entry.label,
|
|
sourceLabel: entry.sourceLabel,
|
|
sourceType: entry.sourceType,
|
|
assetKind: entry.assetKind || '',
|
|
ownerName: entry.ownerName,
|
|
createdAt: entry.createdAt,
|
|
sourceTopicId: entry.sourceTopicId || '',
|
|
sourceTopicName: entry.sourceTopicName || '',
|
|
usageCount: entry.usageCount || 0,
|
|
linkedTemplates: entry.linkedTemplates || [],
|
|
isAssetLibraryItem: !!entry.isAssetLibraryItem,
|
|
tags: entry.tags || [],
|
|
replacedByItemId: entry.replacedByItemId || '',
|
|
replacedBySrc: entry.replacedBySrc || '',
|
|
replacedByLabel: entry.replacedByLabel || '',
|
|
replacedAt: entry.replacedAt || 0,
|
|
})),
|
|
}
|
|
})
|
|
.filter((item) => {
|
|
switch (filterMode) {
|
|
case 'user':
|
|
return item.sourceType === 'user'
|
|
case 'template':
|
|
return item.sourceType === 'template' && !item.isAssetLibraryItem
|
|
case 'asset':
|
|
return item.sourceType === 'asset' || !!item.isAssetLibraryItem
|
|
case 'thumbnail':
|
|
return item.assetKind === 'thumbnail'
|
|
case 'avatar':
|
|
return item.assetKind === 'avatar'
|
|
case 'library':
|
|
return item.sourceType === 'user' || (item.sourceType === 'template' && !item.isAssetLibraryItem)
|
|
case 'unused':
|
|
return (item.sourceType === 'user' && ((item.usageCount === 0 && item.linkedTemplates.length === 0) || !!item.replacedAt)) || item.sourceType === 'asset' || !!item.isAssetLibraryItem
|
|
case 'unused-user':
|
|
return item.sourceType === 'user' && ((item.usageCount === 0 && item.linkedTemplates.length === 0) || !!item.replacedAt)
|
|
case 'replaced-user':
|
|
return item.sourceType === 'user' && !!item.replacedAt
|
|
case 'unused-admin':
|
|
return item.sourceType === 'asset' || !!item.isAssetLibraryItem
|
|
default:
|
|
return true
|
|
}
|
|
})
|
|
.sort((a, b) => Number(b.createdAt || 0) - Number(a.createdAt || 0))
|
|
|
|
const visibleItems = collapseShared ? collapseSharedLibraryItems(allItems) : allItems
|
|
const total = visibleItems.length
|
|
const offset = (normalizedPage - 1) * normalizedLimit
|
|
const pagedItems = visibleItems.slice(offset, offset + normalizedLimit)
|
|
|
|
return {
|
|
items: pagedItems,
|
|
total,
|
|
page: normalizedPage,
|
|
limit: normalizedLimit,
|
|
}
|
|
}
|
|
|
|
async function findUnusedCustomItems({ queryText = '' } = {}) {
|
|
const hasQuery = !!(queryText || '').trim()
|
|
const search = `%${(queryText || '').trim()}%`
|
|
|
|
const [rows, topicItemRows, usageMeta] = await Promise.all([
|
|
query(
|
|
`
|
|
SELECT
|
|
c.id,
|
|
c.owner_id,
|
|
c.src,
|
|
c.label,
|
|
c.tags_json,
|
|
c.replaced_by_item_id,
|
|
c.replaced_by_src,
|
|
c.replaced_by_label,
|
|
c.replaced_at,
|
|
c.created_at,
|
|
u.nickname,
|
|
u.email
|
|
FROM custom_items c
|
|
INNER JOIN users u ON u.id = c.owner_id
|
|
${hasQuery ? 'WHERE c.label LIKE ? OR c.src LIKE ? OR c.tags_json LIKE ? OR u.email LIKE ? OR u.nickname LIKE ?' : ''}
|
|
ORDER BY c.created_at DESC
|
|
`,
|
|
hasQuery ? [search, search, search, search, search] : []
|
|
),
|
|
query(
|
|
`
|
|
SELECT ti.topic_id, tp.name AS topic_name, ti.src
|
|
FROM topic_items ti
|
|
LEFT JOIN topics tp ON tp.id = ti.topic_id
|
|
`
|
|
),
|
|
getCustomItemUsageMeta(),
|
|
])
|
|
|
|
const templateLinkedBySrc = new Map()
|
|
topicItemRows.forEach((row) => {
|
|
if (!row?.src) return
|
|
if (!templateLinkedBySrc.has(row.src)) templateLinkedBySrc.set(row.src, new Map())
|
|
templateLinkedBySrc.get(row.src).set(row.topic_id, {
|
|
id: row.topic_id,
|
|
name: row.topic_name || row.topic_id,
|
|
})
|
|
})
|
|
|
|
return rows
|
|
.map((row) => ({
|
|
...mapCustomItemRow(row),
|
|
ownerName: row.nickname || row.email,
|
|
ownerEmail: row.email,
|
|
usageCount: usageMeta.usageMap.get(row.id) || 0,
|
|
linkedTemplates: Array.from((templateLinkedBySrc.get(row.src) || new Map()).values()),
|
|
}))
|
|
.filter((item) => ((item.usageCount === 0 && item.linkedTemplates.length === 0) || !!item.replacedAt))
|
|
}
|
|
|
|
async function getFavoriteStatsForTierListIds(tierListIds, userId = '') {
|
|
const ids = Array.from(new Set((tierListIds || []).filter(Boolean)))
|
|
const countMap = new Map()
|
|
const favoritedSet = new Set()
|
|
if (!ids.length) return { countMap, favoritedSet }
|
|
|
|
const placeholders = ids.map(() => '?').join(', ')
|
|
const countRows = await query(
|
|
`
|
|
SELECT tierlist_id, COUNT(*) AS favorite_count
|
|
FROM favorite_tierlists
|
|
WHERE tierlist_id IN (${placeholders})
|
|
GROUP BY tierlist_id
|
|
`,
|
|
ids
|
|
)
|
|
|
|
countRows.forEach((row) => {
|
|
countMap.set(row.tierlist_id, Number(row.favorite_count || 0))
|
|
})
|
|
|
|
if (userId) {
|
|
const favoriteRows = await query(
|
|
`
|
|
SELECT tierlist_id
|
|
FROM favorite_tierlists
|
|
WHERE user_id = ? AND tierlist_id IN (${placeholders})
|
|
`,
|
|
[userId, ...ids]
|
|
)
|
|
favoriteRows.forEach((row) => favoritedSet.add(row.tierlist_id))
|
|
}
|
|
|
|
return { countMap, favoritedSet }
|
|
}
|
|
|
|
function applyFavoriteMetaToTierLists(tierLists, favoriteStats) {
|
|
return tierLists.map((tierList) => ({
|
|
...tierList,
|
|
favoriteCount: favoriteStats.countMap.get(tierList.id) || 0,
|
|
isFavorited: favoriteStats.favoritedSet.has(tierList.id),
|
|
}))
|
|
}
|
|
|
|
async function listPublicTierLists(topicId, currentUserId = '', queryText = '') {
|
|
const params = []
|
|
let whereClause = 'WHERE t.is_public = 1'
|
|
if (topicId) {
|
|
const topic = await findTopicByIdentifier(topicId)
|
|
if (!topic) {
|
|
return {
|
|
featuredTierLists: [],
|
|
tierLists: [],
|
|
}
|
|
}
|
|
whereClause += ' AND t.topic_id = ?'
|
|
params.push(topic.id)
|
|
}
|
|
if ((queryText || '').trim()) {
|
|
const search = `%${queryText.trim()}%`
|
|
whereClause += ' AND (t.title LIKE ? OR u.nickname LIKE ? OR u.email LIKE ?)'
|
|
params.push(search, search, search)
|
|
}
|
|
|
|
const rows = await query(
|
|
`
|
|
SELECT
|
|
t.id,
|
|
t.topic_id,
|
|
tp.slug AS topic_slug,
|
|
tp.name AS topic_name,
|
|
t.title,
|
|
t.thumbnail_src,
|
|
t.is_featured,
|
|
t.featured_at,
|
|
t.featured_by,
|
|
t.created_at,
|
|
t.updated_at,
|
|
t.author_id,
|
|
u.nickname,
|
|
u.email,
|
|
u.avatar_src
|
|
FROM tierlists t
|
|
INNER JOIN users u ON u.id = t.author_id
|
|
INNER JOIN topics tp ON tp.id = t.topic_id
|
|
${whereClause}
|
|
ORDER BY t.is_featured DESC, t.featured_at DESC, t.updated_at DESC
|
|
LIMIT 200
|
|
`,
|
|
params
|
|
)
|
|
|
|
const tierLists = rows.map((row) => ({
|
|
id: row.id,
|
|
topicId: row.topic_id,
|
|
topicSlug: row.topic_slug || row.topic_id,
|
|
topicName: row.topic_name || '',
|
|
title: row.title,
|
|
thumbnailSrc: row.thumbnail_src || '',
|
|
isFeatured: !!row.is_featured,
|
|
featuredAt: Number(row.featured_at || 0),
|
|
createdAt: Number(row.created_at),
|
|
updatedAt: Number(row.updated_at),
|
|
authorId: row.author_id,
|
|
authorName: getUserDisplayName(row),
|
|
authorAccountName: getUserAccountName(row),
|
|
authorAvatarSrc: row.avatar_src || '',
|
|
}))
|
|
|
|
const favoriteStats = await getFavoriteStatsForTierListIds(
|
|
tierLists.map((tierList) => tierList.id),
|
|
currentUserId
|
|
)
|
|
const mergedTierLists = applyFavoriteMetaToTierLists(tierLists, favoriteStats)
|
|
const featuredTierLists = mergedTierLists
|
|
.filter((tierList) => tierList.isFeatured)
|
|
.slice()
|
|
.sort(
|
|
(a, b) =>
|
|
Number(b.featuredAt || 0) - Number(a.featuredAt || 0) ||
|
|
Number(b.favoriteCount || 0) - Number(a.favoriteCount || 0) ||
|
|
Number(b.updatedAt || 0) - Number(a.updatedAt || 0)
|
|
)
|
|
.slice(0, 16)
|
|
|
|
return {
|
|
featuredTierLists,
|
|
tierLists: mergedTierLists.filter((tierList) => !tierList.isFeatured),
|
|
}
|
|
}
|
|
|
|
async function listFavoriteTierLists(userId, { queryText = '', sort = 'favorited' } = {}) {
|
|
const allowedSort = new Set(['favorited', 'updated', 'favorites'])
|
|
const normalizedSort = allowedSort.has(sort) ? sort : 'favorited'
|
|
const params = [userId]
|
|
let whereClause = 'WHERE f.user_id = ?'
|
|
|
|
if ((queryText || '').trim()) {
|
|
const search = `%${queryText.trim()}%`
|
|
whereClause += ' AND (t.title LIKE ? OR tp.name LIKE ? OR u.nickname LIKE ? OR u.email LIKE ?)'
|
|
params.push(search, search, search, search)
|
|
}
|
|
|
|
const orderClause =
|
|
normalizedSort === 'updated'
|
|
? 'ORDER BY t.updated_at DESC, f.created_at DESC'
|
|
: normalizedSort === 'favorites'
|
|
? 'ORDER BY favorite_count DESC, t.updated_at DESC'
|
|
: 'ORDER BY f.created_at DESC, t.updated_at DESC'
|
|
|
|
const rows = await query(
|
|
`
|
|
SELECT
|
|
t.id,
|
|
t.author_id,
|
|
t.topic_id,
|
|
tp.slug AS topic_slug,
|
|
tp.name AS topic_name,
|
|
t.title,
|
|
t.thumbnail_src,
|
|
t.description,
|
|
t.is_public,
|
|
t.is_featured,
|
|
t.featured_at,
|
|
t.featured_by,
|
|
t.show_character_names,
|
|
t.icon_size,
|
|
t.source_tierlist_id,
|
|
t.source_snapshot_title,
|
|
t.source_snapshot_author,
|
|
t.groups_json,
|
|
t.pool_json,
|
|
t.created_at,
|
|
t.updated_at,
|
|
f.created_at AS favorited_at,
|
|
u.nickname,
|
|
u.email,
|
|
u.avatar_src,
|
|
(
|
|
SELECT COUNT(*)
|
|
FROM favorite_tierlists ff
|
|
WHERE ff.tierlist_id = t.id
|
|
) AS favorite_count
|
|
FROM favorite_tierlists f
|
|
INNER JOIN tierlists t ON t.id = f.tierlist_id
|
|
INNER JOIN users u ON u.id = t.author_id
|
|
INNER JOIN topics tp ON tp.id = t.topic_id
|
|
${whereClause}
|
|
${orderClause}
|
|
`,
|
|
params
|
|
)
|
|
|
|
return rows.map((row) => ({
|
|
...mapTierListRow(row),
|
|
favoritedAt: Number(row.favorited_at || 0),
|
|
favoriteCount: Number(row.favorite_count || 0),
|
|
isFavorited: true,
|
|
}))
|
|
}
|
|
|
|
async function listUserTierLists(userId) {
|
|
const rows = await query(
|
|
`
|
|
SELECT
|
|
t.id,
|
|
t.topic_id,
|
|
tp.slug AS topic_slug,
|
|
tp.name AS topic_name,
|
|
t.title,
|
|
t.thumbnail_src,
|
|
t.created_at,
|
|
t.updated_at,
|
|
t.is_public,
|
|
u.nickname,
|
|
u.email,
|
|
u.avatar_src
|
|
FROM tierlists t
|
|
INNER JOIN users u ON u.id = t.author_id
|
|
INNER JOIN topics tp ON tp.id = t.topic_id
|
|
WHERE t.author_id = ?
|
|
ORDER BY updated_at DESC
|
|
`,
|
|
[userId]
|
|
)
|
|
|
|
const tierLists = rows.map((row) => ({
|
|
id: row.id,
|
|
topicId: row.topic_id,
|
|
topicSlug: row.topic_slug || row.topic_id,
|
|
topicName: row.topic_name || '',
|
|
title: row.title,
|
|
thumbnailSrc: row.thumbnail_src || '',
|
|
createdAt: Number(row.created_at),
|
|
updatedAt: Number(row.updated_at),
|
|
isPublic: !!row.is_public,
|
|
authorName: getUserDisplayName(row),
|
|
authorAccountName: getUserAccountName(row),
|
|
authorAvatarSrc: row.avatar_src || '',
|
|
}))
|
|
|
|
const favoriteStats = await getFavoriteStatsForTierListIds(
|
|
tierLists.map((tierList) => tierList.id),
|
|
userId
|
|
)
|
|
return applyFavoriteMetaToTierLists(tierLists, favoriteStats)
|
|
}
|
|
|
|
async function findUserProfileById(userId, currentUserId = '') {
|
|
const rows = await query(
|
|
`
|
|
SELECT
|
|
u.id,
|
|
u.email,
|
|
u.nickname,
|
|
u.avatar_src,
|
|
u.created_at,
|
|
(
|
|
SELECT COUNT(*)
|
|
FROM tierlists t
|
|
WHERE t.author_id = u.id AND t.is_public = 1
|
|
) AS public_tierlist_count,
|
|
(
|
|
SELECT COUNT(*)
|
|
FROM user_follows uf
|
|
WHERE uf.following_id = u.id
|
|
) AS follower_count,
|
|
(
|
|
SELECT COUNT(*)
|
|
FROM user_follows uf
|
|
WHERE uf.follower_id = u.id
|
|
) AS following_count,
|
|
${
|
|
currentUserId
|
|
? `EXISTS(
|
|
SELECT 1
|
|
FROM user_follows uf
|
|
WHERE uf.follower_id = ? AND uf.following_id = u.id
|
|
)`
|
|
: '0'
|
|
} AS is_following
|
|
FROM users u
|
|
WHERE u.id = ?
|
|
LIMIT 1
|
|
`,
|
|
currentUserId ? [currentUserId, userId] : [userId]
|
|
)
|
|
const row = rows[0]
|
|
if (!row) return null
|
|
return {
|
|
id: row.id,
|
|
nickname: row.nickname || '',
|
|
accountName: getUserAccountName(row),
|
|
avatarSrc: row.avatar_src || '',
|
|
createdAt: Number(row.created_at || 0),
|
|
publicTierListCount: Number(row.public_tierlist_count || 0),
|
|
followerCount: Number(row.follower_count || 0),
|
|
followingCount: Number(row.following_count || 0),
|
|
isFollowing: !!row.is_following,
|
|
isSelf: !!currentUserId && currentUserId === row.id,
|
|
}
|
|
}
|
|
|
|
async function followUser({ followerId, followingId }) {
|
|
await query('INSERT IGNORE INTO user_follows (follower_id, following_id, created_at) VALUES (?, ?, ?)', [
|
|
followerId,
|
|
followingId,
|
|
now(),
|
|
])
|
|
}
|
|
|
|
async function unfollowUser({ followerId, followingId }) {
|
|
await query('DELETE FROM user_follows WHERE follower_id = ? AND following_id = ?', [followerId, followingId])
|
|
}
|
|
|
|
async function listPublicTierListsByAuthor(authorId, currentUserId = '', queryText = '') {
|
|
const params = [authorId]
|
|
let whereClause = 'WHERE t.author_id = ? AND t.is_public = 1'
|
|
if ((queryText || '').trim()) {
|
|
const search = `%${queryText.trim()}%`
|
|
whereClause += ' AND (t.title LIKE ? OR tp.name LIKE ?)'
|
|
params.push(search, search)
|
|
}
|
|
|
|
const rows = await query(
|
|
`
|
|
SELECT
|
|
t.id,
|
|
t.topic_id,
|
|
tp.slug AS topic_slug,
|
|
tp.name AS topic_name,
|
|
t.title,
|
|
t.thumbnail_src,
|
|
t.is_public,
|
|
t.is_featured,
|
|
t.featured_at,
|
|
t.featured_by,
|
|
t.created_at,
|
|
t.updated_at,
|
|
t.author_id,
|
|
u.nickname,
|
|
u.email,
|
|
u.avatar_src
|
|
FROM tierlists t
|
|
INNER JOIN users u ON u.id = t.author_id
|
|
INNER JOIN topics tp ON tp.id = t.topic_id
|
|
${whereClause}
|
|
ORDER BY t.is_featured DESC, t.featured_at DESC, t.updated_at DESC
|
|
LIMIT 200
|
|
`,
|
|
params
|
|
)
|
|
|
|
const tierLists = rows.map((row) => ({
|
|
id: row.id,
|
|
topicId: row.topic_id,
|
|
topicSlug: row.topic_slug || row.topic_id,
|
|
topicName: row.topic_name || '',
|
|
title: row.title,
|
|
thumbnailSrc: row.thumbnail_src || '',
|
|
isPublic: !!row.is_public,
|
|
isFeatured: !!row.is_featured,
|
|
featuredAt: Number(row.featured_at || 0),
|
|
createdAt: Number(row.created_at),
|
|
updatedAt: Number(row.updated_at),
|
|
authorId: row.author_id,
|
|
authorName: getUserDisplayName(row),
|
|
authorAccountName: getUserAccountName(row),
|
|
authorAvatarSrc: row.avatar_src || '',
|
|
}))
|
|
|
|
const favoriteStats = await getFavoriteStatsForTierListIds(
|
|
tierLists.map((tierList) => tierList.id),
|
|
currentUserId
|
|
)
|
|
return applyFavoriteMetaToTierLists(tierLists, favoriteStats)
|
|
}
|
|
|
|
async function listFollowingTierLists(userId, queryText = '') {
|
|
const params = [userId]
|
|
let whereClause = 'WHERE uf.follower_id = ? AND t.is_public = 1'
|
|
if ((queryText || '').trim()) {
|
|
const search = `%${queryText.trim()}%`
|
|
whereClause += ' AND (t.title LIKE ? OR tp.name LIKE ? OR u.nickname LIKE ? OR u.email LIKE ?)'
|
|
params.push(search, search, search, search)
|
|
}
|
|
|
|
const rows = await query(
|
|
`
|
|
SELECT
|
|
t.id,
|
|
t.topic_id,
|
|
tp.slug AS topic_slug,
|
|
tp.name AS topic_name,
|
|
t.title,
|
|
t.thumbnail_src,
|
|
t.is_public,
|
|
t.is_featured,
|
|
t.featured_at,
|
|
t.featured_by,
|
|
t.created_at,
|
|
t.updated_at,
|
|
t.author_id,
|
|
uf.created_at AS followed_at,
|
|
u.nickname,
|
|
u.email,
|
|
u.avatar_src
|
|
FROM user_follows uf
|
|
INNER JOIN tierlists t ON t.author_id = uf.following_id
|
|
INNER JOIN users u ON u.id = t.author_id
|
|
INNER JOIN topics tp ON tp.id = t.topic_id
|
|
${whereClause}
|
|
ORDER BY t.updated_at DESC, uf.created_at DESC
|
|
LIMIT 200
|
|
`,
|
|
params
|
|
)
|
|
|
|
const tierLists = rows.map((row) => ({
|
|
id: row.id,
|
|
topicId: row.topic_id,
|
|
topicSlug: row.topic_slug || row.topic_id,
|
|
topicName: row.topic_name || '',
|
|
title: row.title,
|
|
thumbnailSrc: row.thumbnail_src || '',
|
|
isPublic: !!row.is_public,
|
|
isFeatured: !!row.is_featured,
|
|
featuredAt: Number(row.featured_at || 0),
|
|
createdAt: Number(row.created_at),
|
|
updatedAt: Number(row.updated_at),
|
|
authorId: row.author_id,
|
|
authorName: getUserDisplayName(row),
|
|
authorAccountName: getUserAccountName(row),
|
|
authorAvatarSrc: row.avatar_src || '',
|
|
isFavorited: false,
|
|
}))
|
|
|
|
const favoriteStats = await getFavoriteStatsForTierListIds(
|
|
tierLists.map((tierList) => tierList.id),
|
|
userId
|
|
)
|
|
return applyFavoriteMetaToTierLists(tierLists, favoriteStats)
|
|
}
|
|
|
|
async function listTierListComments(tierListId) {
|
|
const rows = await query(
|
|
`
|
|
SELECT
|
|
c.id,
|
|
c.tierlist_id,
|
|
c.author_id,
|
|
c.parent_comment_id,
|
|
c.content,
|
|
c.created_at,
|
|
c.updated_at,
|
|
u.nickname,
|
|
u.email,
|
|
u.avatar_src
|
|
FROM tierlist_comments c
|
|
INNER JOIN users u ON u.id = c.author_id
|
|
WHERE c.tierlist_id = ?
|
|
ORDER BY c.created_at ASC, c.id ASC
|
|
`,
|
|
[tierListId]
|
|
)
|
|
|
|
const comments = rows.map(mapTierListCommentRow)
|
|
const byId = new Map(comments.map((comment) => [comment.id, comment]))
|
|
const roots = []
|
|
comments.forEach((comment) => {
|
|
if (comment.parentCommentId) {
|
|
const parent = byId.get(comment.parentCommentId)
|
|
if (parent) {
|
|
parent.replies.push(comment)
|
|
return
|
|
}
|
|
}
|
|
roots.push(comment)
|
|
})
|
|
roots.sort((a, b) => {
|
|
const timeDiff = Number(b.createdAt || 0) - Number(a.createdAt || 0)
|
|
if (timeDiff !== 0) return timeDiff
|
|
return String(b.id || '').localeCompare(String(a.id || ''))
|
|
})
|
|
return roots
|
|
}
|
|
|
|
async function findTierListCommentById(commentId) {
|
|
const rows = await query(
|
|
`
|
|
SELECT id, tierlist_id, author_id, parent_comment_id, content, created_at, updated_at
|
|
FROM tierlist_comments
|
|
WHERE id = ?
|
|
LIMIT 1
|
|
`,
|
|
[commentId]
|
|
)
|
|
const row = rows[0]
|
|
if (!row) return null
|
|
return {
|
|
id: row.id,
|
|
tierListId: row.tierlist_id,
|
|
authorId: row.author_id,
|
|
parentCommentId: row.parent_comment_id || '',
|
|
content: row.content || '',
|
|
createdAt: Number(row.created_at || 0),
|
|
updatedAt: Number(row.updated_at || 0),
|
|
}
|
|
}
|
|
|
|
async function createTierListComment({ tierListId, authorId, parentCommentId = '', content }) {
|
|
let parentComment = null
|
|
if (parentCommentId) {
|
|
parentComment = await findTierListCommentById(parentCommentId)
|
|
if (!parentComment || parentComment.tierListId !== tierListId) {
|
|
const error = new Error('comment_parent_invalid')
|
|
error.code = 'COMMENT_PARENT_INVALID'
|
|
throw error
|
|
}
|
|
if (parentComment.parentCommentId) {
|
|
const error = new Error('comment_reply_depth_invalid')
|
|
error.code = 'COMMENT_REPLY_DEPTH_INVALID'
|
|
throw error
|
|
}
|
|
}
|
|
|
|
const commentId = nanoid()
|
|
const createdAt = now()
|
|
await query(
|
|
`
|
|
INSERT INTO tierlist_comments (id, tierlist_id, author_id, parent_comment_id, content, created_at, updated_at)
|
|
VALUES (?, ?, ?, ?, ?, ?, ?)
|
|
`,
|
|
[commentId, tierListId, authorId, parentComment ? parentComment.id : null, String(content || '').trim(), createdAt, createdAt]
|
|
)
|
|
return commentId
|
|
}
|
|
|
|
async function deleteTierListComment(commentId) {
|
|
await query('DELETE FROM tierlist_comments WHERE id = ?', [commentId])
|
|
}
|
|
|
|
async function createCommentNotificationsForComment(commentId) {
|
|
const comment = await findTierListCommentById(commentId)
|
|
if (!comment) return
|
|
|
|
const tierList = await findTierListById(comment.tierListId)
|
|
if (!tierList) return
|
|
|
|
const recipientMap = new Map()
|
|
if (tierList.authorId && tierList.authorId !== comment.authorId) {
|
|
recipientMap.set(tierList.authorId, 'tierlist_comment')
|
|
}
|
|
|
|
if (comment.parentCommentId) {
|
|
const parentComment = await findTierListCommentById(comment.parentCommentId)
|
|
if (parentComment && parentComment.authorId && parentComment.authorId !== comment.authorId) {
|
|
recipientMap.set(parentComment.authorId, 'comment_reply')
|
|
}
|
|
}
|
|
|
|
await Promise.all(
|
|
Array.from(recipientMap.entries()).map(([userId, notificationType]) =>
|
|
query(
|
|
`
|
|
INSERT INTO comment_notifications (id, user_id, tierlist_id, comment_id, actor_user_id, notification_type, is_read, read_at, created_at)
|
|
VALUES (?, ?, ?, ?, ?, ?, 0, 0, ?)
|
|
`,
|
|
[nanoid(), userId, comment.tierListId, comment.id, comment.authorId, notificationType, now()]
|
|
)
|
|
)
|
|
)
|
|
}
|
|
|
|
async function listCommentNotifications(userId, { unreadOnly = false } = {}) {
|
|
const rows = await query(
|
|
`
|
|
SELECT
|
|
n.id,
|
|
n.user_id,
|
|
n.tierlist_id,
|
|
n.comment_id,
|
|
n.notification_type,
|
|
n.is_read,
|
|
n.read_at,
|
|
n.created_at,
|
|
n.actor_user_id,
|
|
c.parent_comment_id,
|
|
c.content AS comment_content,
|
|
parent.content AS parent_comment_content,
|
|
parent.created_at AS parent_comment_created_at,
|
|
t.topic_id,
|
|
tp.slug AS topic_slug,
|
|
tp.name AS topic_name,
|
|
t.title AS tierlist_title,
|
|
t.thumbnail_src AS tierlist_thumbnail_src,
|
|
actor.nickname AS actor_nickname,
|
|
actor.email AS actor_email,
|
|
actor.avatar_src AS actor_avatar_src,
|
|
parent_author.nickname AS parent_author_nickname,
|
|
parent_author.email AS parent_author_email,
|
|
parent_author.avatar_src AS parent_author_avatar_src
|
|
FROM comment_notifications n
|
|
INNER JOIN tierlist_comments c ON c.id = n.comment_id
|
|
LEFT JOIN tierlist_comments parent ON parent.id = c.parent_comment_id
|
|
LEFT JOIN users parent_author ON parent_author.id = parent.author_id
|
|
INNER JOIN tierlists t ON t.id = n.tierlist_id
|
|
INNER JOIN topics tp ON tp.id = t.topic_id
|
|
INNER JOIN users actor ON actor.id = n.actor_user_id
|
|
WHERE n.user_id = ?
|
|
${unreadOnly ? 'AND n.is_read = 0' : ''}
|
|
ORDER BY n.is_read ASC, n.created_at DESC
|
|
LIMIT 300
|
|
`,
|
|
[userId]
|
|
)
|
|
return rows.map(mapCommentNotificationRow)
|
|
}
|
|
|
|
async function countUnreadCommentNotifications(userId) {
|
|
const rows = await query('SELECT COUNT(*) AS count FROM comment_notifications WHERE user_id = ? AND is_read = 0', [userId])
|
|
return Number(rows[0]?.count || 0)
|
|
}
|
|
|
|
async function markCommentNotificationsRead(userId, { notificationIds = [], all = false } = {}) {
|
|
if (all) {
|
|
await query('UPDATE comment_notifications SET is_read = 1, read_at = ? WHERE user_id = ? AND is_read = 0', [now(), userId])
|
|
return
|
|
}
|
|
|
|
const ids = Array.from(new Set((notificationIds || []).filter(Boolean))).slice(0, 100)
|
|
if (!ids.length) return
|
|
await query(
|
|
`UPDATE comment_notifications SET is_read = 1, read_at = ? WHERE user_id = ? AND id IN (${ids.map(() => '?').join(', ')}) AND is_read = 0`,
|
|
[now(), userId, ...ids]
|
|
)
|
|
}
|
|
|
|
function uniqueTierListItems(poolItems) {
|
|
const map = new Map()
|
|
;(poolItems || []).forEach((item) => {
|
|
if (!item?.id || map.has(item.id)) return
|
|
map.set(item.id, {
|
|
id: item.id,
|
|
src: item.src || '',
|
|
label: item.label || 'item',
|
|
origin: item.origin || 'template',
|
|
})
|
|
})
|
|
return Array.from(map.values())
|
|
}
|
|
|
|
function getAutoThumbnailSrc(groups = [], pool = []) {
|
|
const itemMap = new Map((pool || []).filter((item) => item?.id && item?.src).map((item) => [item.id, item]))
|
|
|
|
for (const group of groups || []) {
|
|
for (const itemId of group?.itemIds || []) {
|
|
const item = itemMap.get(itemId)
|
|
if (item?.src) return item.src
|
|
}
|
|
}
|
|
|
|
const fallbackItem = (pool || []).find((item) => item?.src)
|
|
return fallbackItem?.src || ''
|
|
}
|
|
|
|
async function listAdminTierLists({
|
|
queryText = '',
|
|
topicId = '',
|
|
page = 1,
|
|
limit = 50,
|
|
sort = 'recent',
|
|
minFavorites = 0,
|
|
currentUserId = '',
|
|
} = {}) {
|
|
const normalizedLimit = Math.min(Math.max(Number(limit) || 50, 1), 200)
|
|
const normalizedPage = Math.max(Number(page) || 1, 1)
|
|
const normalizedMinFavorites = Math.max(Number(minFavorites) || 0, 0)
|
|
const hasQuery = !!(queryText || '').trim()
|
|
const resolvedTopicId = (topicId || '').trim()
|
|
const hasTopicId = !!resolvedTopicId
|
|
const search = `%${(queryText || '').trim()}%`
|
|
const whereParts = []
|
|
const params = []
|
|
|
|
if (hasTopicId) {
|
|
whereParts.push('t.topic_id = ?')
|
|
params.push(resolvedTopicId)
|
|
}
|
|
|
|
if (hasQuery) {
|
|
whereParts.push(`(
|
|
t.title LIKE ?
|
|
OR tp.name LIKE ?
|
|
OR tp.slug LIKE ?
|
|
OR tp.id LIKE ?
|
|
OR u.email LIKE ?
|
|
OR u.nickname LIKE ?
|
|
)`)
|
|
params.push(search, search, search, search, search, search)
|
|
}
|
|
|
|
const whereClause = whereParts.length ? `WHERE ${whereParts.join(' AND ')}` : ''
|
|
|
|
const rows = await query(
|
|
`
|
|
SELECT
|
|
t.id,
|
|
t.author_id,
|
|
t.topic_id,
|
|
tp.slug AS topic_slug,
|
|
tp.name AS topic_name,
|
|
t.title,
|
|
t.thumbnail_src,
|
|
t.description,
|
|
t.is_public,
|
|
t.is_featured,
|
|
t.featured_at,
|
|
t.featured_by,
|
|
t.show_character_names,
|
|
t.icon_size,
|
|
t.source_tierlist_id,
|
|
t.source_snapshot_title,
|
|
t.source_snapshot_author,
|
|
t.groups_json,
|
|
t.pool_json,
|
|
t.created_at,
|
|
t.updated_at,
|
|
u.nickname,
|
|
u.email,
|
|
u.avatar_src
|
|
FROM tierlists t
|
|
INNER JOIN users u ON u.id = t.author_id
|
|
INNER JOIN topics tp ON tp.id = t.topic_id
|
|
${whereClause}
|
|
ORDER BY t.updated_at DESC, t.created_at DESC
|
|
`,
|
|
params
|
|
)
|
|
|
|
const baseItems = rows.map((row) => {
|
|
const tierList = mapTierListRow(row)
|
|
const poolItems = uniqueTierListItems(tierList.pool)
|
|
const extraItems = poolItems.filter((item) => item.origin === 'custom')
|
|
return {
|
|
...tierList,
|
|
itemCount: poolItems.length,
|
|
extraItemCount: extraItems.length,
|
|
extraItems,
|
|
}
|
|
})
|
|
const favoriteStats = await getFavoriteStatsForTierListIds(
|
|
baseItems.map((tierList) => tierList.id),
|
|
currentUserId
|
|
)
|
|
const filteredItems = applyFavoriteMetaToTierLists(baseItems, favoriteStats)
|
|
.filter((tierList) => Number(tierList.favoriteCount || 0) >= normalizedMinFavorites)
|
|
.sort((a, b) => {
|
|
if (sort === 'favorites') {
|
|
return (
|
|
Number(b.favoriteCount || 0) - Number(a.favoriteCount || 0) ||
|
|
Number(b.updatedAt || 0) - Number(a.updatedAt || 0) ||
|
|
Number(b.createdAt || 0) - Number(a.createdAt || 0)
|
|
)
|
|
}
|
|
if (sort === 'created') {
|
|
return (
|
|
Number(b.createdAt || 0) - Number(a.createdAt || 0) ||
|
|
Number(b.updatedAt || 0) - Number(a.updatedAt || 0) ||
|
|
String(a.title || '').localeCompare(String(b.title || ''))
|
|
)
|
|
}
|
|
return (
|
|
Number(b.updatedAt || 0) - Number(a.updatedAt || 0) ||
|
|
Number(b.createdAt || 0) - Number(a.createdAt || 0) ||
|
|
String(a.title || '').localeCompare(String(b.title || ''))
|
|
)
|
|
})
|
|
|
|
const total = filteredItems.length
|
|
const offset = (normalizedPage - 1) * normalizedLimit
|
|
const pagedTierLists = filteredItems.slice(offset, offset + normalizedLimit)
|
|
return {
|
|
tierLists: pagedTierLists,
|
|
total,
|
|
page: normalizedPage,
|
|
limit: normalizedLimit,
|
|
}
|
|
}
|
|
|
|
async function summarizeAdminTierLists({ queryText = '', topicId = '', minFavorites = 0 } = {}) {
|
|
const normalizedMinFavorites = Math.max(Number(minFavorites) || 0, 0)
|
|
const hasQuery = !!(queryText || '').trim()
|
|
const resolvedTopicId = (topicId || '').trim()
|
|
const hasTopicId = !!resolvedTopicId
|
|
const search = `%${(queryText || '').trim()}%`
|
|
const whereParts = []
|
|
const params = []
|
|
|
|
if (hasTopicId) {
|
|
whereParts.push('t.topic_id = ?')
|
|
params.push(resolvedTopicId)
|
|
}
|
|
|
|
if (hasQuery) {
|
|
whereParts.push(`(
|
|
t.title LIKE ?
|
|
OR tp.name LIKE ?
|
|
OR tp.slug LIKE ?
|
|
OR tp.id LIKE ?
|
|
OR u.email LIKE ?
|
|
OR u.nickname LIKE ?
|
|
)`)
|
|
params.push(search, search, search, search, search, search)
|
|
}
|
|
|
|
const whereClause = whereParts.length ? `WHERE ${whereParts.join(' AND ')}` : ''
|
|
const rows = await query(
|
|
`
|
|
SELECT t.is_public, t.is_featured
|
|
, t.id
|
|
FROM tierlists t
|
|
INNER JOIN users u ON u.id = t.author_id
|
|
INNER JOIN topics tp ON tp.id = t.topic_id
|
|
${whereClause}
|
|
`,
|
|
params
|
|
)
|
|
|
|
const favoriteStats = normalizedMinFavorites > 0
|
|
? await getFavoriteStatsForTierListIds(rows.map((row) => row.id), '')
|
|
: { countMap: new Map(), favoritedSet: new Set() }
|
|
const scopedRows = normalizedMinFavorites > 0
|
|
? rows.filter((row) => Number(favoriteStats.countMap.get(row.id) || 0) >= normalizedMinFavorites)
|
|
: rows
|
|
|
|
const total = scopedRows.length
|
|
const publicCount = scopedRows.filter((row) => Number(row.is_public) === 1).length
|
|
const featuredCount = scopedRows.filter((row) => Number(row.is_featured) === 1).length
|
|
return {
|
|
total,
|
|
publicCount,
|
|
privateCount: Math.max(0, total - publicCount),
|
|
featuredCount,
|
|
}
|
|
}
|
|
|
|
async function findTierListById(id, currentUserId = '') {
|
|
const rows = await query(
|
|
`
|
|
SELECT
|
|
t.id,
|
|
t.author_id,
|
|
t.topic_id,
|
|
tp.slug AS topic_slug,
|
|
tp.name AS topic_name,
|
|
t.title,
|
|
t.thumbnail_src,
|
|
t.description,
|
|
t.is_public,
|
|
t.is_featured,
|
|
t.featured_at,
|
|
t.featured_by,
|
|
t.show_character_names,
|
|
t.icon_size,
|
|
t.source_tierlist_id,
|
|
t.source_snapshot_title,
|
|
t.source_snapshot_author,
|
|
t.groups_json,
|
|
t.pool_json,
|
|
t.created_at,
|
|
t.updated_at,
|
|
u.nickname,
|
|
u.email,
|
|
u.avatar_src
|
|
FROM tierlists t
|
|
INNER JOIN users u ON u.id = t.author_id
|
|
INNER JOIN topics tp ON tp.id = t.topic_id
|
|
WHERE t.id = ?
|
|
LIMIT 1
|
|
`,
|
|
[id]
|
|
)
|
|
const tierList = mapTierListRow(rows[0])
|
|
if (!tierList) return null
|
|
const favoriteStats = await getFavoriteStatsForTierListIds([tierList.id], currentUserId)
|
|
return applyFavoriteMetaToTierLists([tierList], favoriteStats)[0]
|
|
}
|
|
|
|
async function findPendingTemplateRequestByTierList({ sourceTierListId, type }) {
|
|
const rows = await query(
|
|
`
|
|
SELECT id, request_type, status
|
|
FROM template_requests
|
|
WHERE source_tierlist_id = ? AND request_type = ? AND status = 'pending'
|
|
LIMIT 1
|
|
`,
|
|
[sourceTierListId, type]
|
|
)
|
|
return rows[0] || null
|
|
}
|
|
|
|
async function createTemplateRequest({
|
|
id,
|
|
type,
|
|
requesterId,
|
|
sourceTierListId = '',
|
|
sourceTopicId,
|
|
targetTopicId = '',
|
|
title,
|
|
description = '',
|
|
thumbnailSrc = '',
|
|
items = [],
|
|
groups = [],
|
|
boardItems = [],
|
|
showCharacterNames = false,
|
|
}) {
|
|
if (sourceTierListId) {
|
|
const existing = await findPendingTemplateRequestByTierList({ sourceTierListId, type })
|
|
if (existing) {
|
|
const err = new Error('template_request_exists')
|
|
err.code = 'TEMPLATE_REQUEST_EXISTS'
|
|
throw err
|
|
}
|
|
}
|
|
|
|
const createdAt = now()
|
|
await query(
|
|
`
|
|
INSERT INTO template_requests (
|
|
id,
|
|
request_type,
|
|
requester_id,
|
|
source_tierlist_id,
|
|
source_topic_id,
|
|
target_topic_id,
|
|
status,
|
|
title_snapshot,
|
|
description_snapshot,
|
|
thumbnail_src_snapshot,
|
|
items_json,
|
|
groups_json,
|
|
board_items_json,
|
|
show_character_names_snapshot,
|
|
created_at,
|
|
updated_at
|
|
)
|
|
VALUES (?, ?, ?, ?, ?, ?, 'pending', ?, ?, ?, ?, ?, ?, ?, ?, ?)
|
|
`,
|
|
[
|
|
id,
|
|
type,
|
|
requesterId,
|
|
sourceTierListId || null,
|
|
sourceTopicId,
|
|
targetTopicId,
|
|
title,
|
|
description,
|
|
thumbnailSrc,
|
|
serializeJson(items),
|
|
serializeJson(groups),
|
|
serializeJson(boardItems),
|
|
showCharacterNames ? 1 : 0,
|
|
createdAt,
|
|
createdAt,
|
|
]
|
|
)
|
|
return findTemplateRequestById(id)
|
|
}
|
|
|
|
async function findTemplateRequestById(id) {
|
|
const rows = await query(
|
|
`
|
|
SELECT
|
|
tr.id,
|
|
tr.request_type,
|
|
tr.requester_id,
|
|
tr.source_tierlist_id,
|
|
tr.source_topic_id,
|
|
tr.target_topic_id,
|
|
tr.status,
|
|
tr.title_snapshot,
|
|
tr.description_snapshot,
|
|
tr.thumbnail_src_snapshot,
|
|
tr.items_json,
|
|
tr.groups_json,
|
|
tr.board_items_json,
|
|
tr.show_character_names_snapshot,
|
|
tr.created_at,
|
|
tr.updated_at,
|
|
u.nickname,
|
|
u.email,
|
|
u.avatar_src AS requester_avatar_src,
|
|
sg.slug AS source_topic_slug,
|
|
sg.name AS source_topic_name,
|
|
tg.slug AS target_topic_slug,
|
|
tg.name AS target_topic_name
|
|
FROM template_requests tr
|
|
INNER JOIN users u ON u.id = tr.requester_id
|
|
LEFT JOIN topics sg ON sg.id = tr.source_topic_id
|
|
LEFT JOIN topics tg ON tg.id = tr.target_topic_id
|
|
WHERE tr.id = ?
|
|
LIMIT 1
|
|
`,
|
|
[id]
|
|
)
|
|
|
|
return mapTemplateRequestRow(rows[0])
|
|
}
|
|
|
|
async function listAdminTemplateRequests({ status = 'pending', statuses = [] } = {}) {
|
|
const requestedStatuses = Array.isArray(statuses) && statuses.length ? statuses : [status]
|
|
const validStatuses = requestedStatuses.filter((entry) => typeof entry === 'string' && entry.trim())
|
|
const normalizedStatuses = validStatuses.length ? validStatuses : ['pending']
|
|
const placeholders = normalizedStatuses.map(() => '?').join(', ')
|
|
const rows = await query(
|
|
`
|
|
SELECT
|
|
tr.id,
|
|
tr.request_type,
|
|
tr.requester_id,
|
|
tr.source_tierlist_id,
|
|
tr.source_topic_id,
|
|
tr.target_topic_id,
|
|
tr.status,
|
|
tr.title_snapshot,
|
|
tr.description_snapshot,
|
|
tr.thumbnail_src_snapshot,
|
|
tr.items_json,
|
|
tr.groups_json,
|
|
tr.board_items_json,
|
|
tr.show_character_names_snapshot,
|
|
tr.created_at,
|
|
tr.updated_at,
|
|
u.nickname,
|
|
u.email,
|
|
u.avatar_src AS requester_avatar_src,
|
|
sg.slug AS source_topic_slug,
|
|
sg.name AS source_topic_name,
|
|
tg.slug AS target_topic_slug,
|
|
tg.name AS target_topic_name
|
|
FROM template_requests tr
|
|
INNER JOIN users u ON u.id = tr.requester_id
|
|
LEFT JOIN topics sg ON sg.id = tr.source_topic_id
|
|
LEFT JOIN topics tg ON tg.id = tr.target_topic_id
|
|
WHERE tr.status IN (${placeholders})
|
|
ORDER BY
|
|
CASE tr.status
|
|
WHEN 'pending' THEN 0
|
|
WHEN 'reviewing' THEN 1
|
|
ELSE 2
|
|
END,
|
|
tr.created_at DESC
|
|
`,
|
|
normalizedStatuses
|
|
)
|
|
|
|
return rows.map(mapTemplateRequestRow)
|
|
}
|
|
|
|
async function updateTemplateRequestStatus({ id, status }) {
|
|
await query('UPDATE template_requests SET status = ?, updated_at = ? WHERE id = ?', [status, now(), id])
|
|
return findTemplateRequestById(id)
|
|
}
|
|
|
|
async function updateTemplateRequestTargetTopic({ id, targetTopicId }) {
|
|
await query('UPDATE template_requests SET target_topic_id = ?, updated_at = ? WHERE id = ?', [targetTopicId || '', now(), id])
|
|
return findTemplateRequestById(id)
|
|
}
|
|
|
|
async function deleteTierList(id) {
|
|
await query('DELETE FROM tierlists WHERE id = ?', [id])
|
|
}
|
|
|
|
async function updateAdminTierListMeta({ id, title, description = '', isPublic }) {
|
|
const nextUpdatedAt = now()
|
|
if (!isPublic) {
|
|
await query(
|
|
`
|
|
UPDATE tierlists
|
|
SET title = ?, description = ?, is_public = 0, is_featured = 0, featured_at = 0, featured_by = '', updated_at = ?
|
|
WHERE id = ?
|
|
`,
|
|
[title, description || '', nextUpdatedAt, id]
|
|
)
|
|
return findTierListById(id)
|
|
}
|
|
|
|
await query(
|
|
`
|
|
UPDATE tierlists
|
|
SET title = ?, description = ?, is_public = ?, updated_at = ?
|
|
WHERE id = ?
|
|
`,
|
|
[title, description || '', 1, nextUpdatedAt, id]
|
|
)
|
|
return findTierListById(id)
|
|
}
|
|
|
|
async function updateTierListFeaturedStatus({ id, isFeatured, adminUserId }) {
|
|
await query(
|
|
`
|
|
UPDATE tierlists
|
|
SET is_featured = ?, featured_at = ?, featured_by = ?
|
|
WHERE id = ?
|
|
`,
|
|
[isFeatured ? 1 : 0, isFeatured ? now() : 0, isFeatured ? adminUserId || '' : '', id]
|
|
)
|
|
return findTierListById(id)
|
|
}
|
|
|
|
async function findCustomItemsByIds(ids) {
|
|
if (!ids.length) return []
|
|
const placeholders = ids.map(() => '?').join(', ')
|
|
const rows = await query(
|
|
`
|
|
SELECT id, owner_id, src, label, tags_json, replaced_by_item_id, replaced_by_src, replaced_by_label, replaced_at, created_at
|
|
FROM custom_items
|
|
WHERE id IN (${placeholders})
|
|
`,
|
|
ids
|
|
)
|
|
|
|
return rows.map(mapCustomItemRow)
|
|
}
|
|
|
|
async function deleteCustomItems(ids) {
|
|
if (!ids.length) return
|
|
const placeholders = ids.map(() => '?').join(', ')
|
|
await query(`DELETE FROM custom_items WHERE id IN (${placeholders})`, ids)
|
|
}
|
|
|
|
async function saveTierList({
|
|
id,
|
|
authorId,
|
|
topicId,
|
|
title,
|
|
thumbnailSrc = '',
|
|
description,
|
|
isPublic,
|
|
showCharacterNames = false,
|
|
iconSize = 80,
|
|
sourceTierListId = '',
|
|
sourceSnapshotTitle = '',
|
|
sourceSnapshotAuthor = '',
|
|
groups,
|
|
pool,
|
|
}) {
|
|
const existing = id ? await findTierListById(id, authorId) : null
|
|
await syncOwnedCustomItemLabels({ ownerId: authorId, items: pool })
|
|
const nextThumbnailSrc = (thumbnailSrc || '').trim() || getAutoThumbnailSrc(groups, pool)
|
|
|
|
if (existing) {
|
|
await query(
|
|
`
|
|
UPDATE tierlists
|
|
SET title = ?, thumbnail_src = ?, description = ?, is_public = ?, show_character_names = ?, icon_size = ?, source_tierlist_id = ?, source_snapshot_title = ?, source_snapshot_author = ?, groups_json = ?, pool_json = ?, updated_at = ?
|
|
WHERE id = ?
|
|
`,
|
|
[title, nextThumbnailSrc, description || '', isPublic ? 1 : 0, showCharacterNames ? 1 : 0, Number(iconSize) || 80, sourceTierListId || null, sourceSnapshotTitle || '', sourceSnapshotAuthor || '', serializeJson(groups), serializeJson(pool), now(), existing.id]
|
|
)
|
|
return findTierListById(existing.id, authorId)
|
|
}
|
|
|
|
const nextId = id || nanoid()
|
|
const createdAt = now()
|
|
await query(
|
|
`
|
|
INSERT INTO tierlists (
|
|
id, author_id, topic_id, title, thumbnail_src, description, is_public, show_character_names, icon_size, source_tierlist_id, source_snapshot_title, source_snapshot_author, groups_json, pool_json, created_at, updated_at
|
|
)
|
|
VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
|
|
`,
|
|
[nextId, authorId, topicId, title, nextThumbnailSrc, description || '', isPublic ? 1 : 0, showCharacterNames ? 1 : 0, Number(iconSize) || 80, sourceTierListId || null, sourceSnapshotTitle || '', sourceSnapshotAuthor || '', serializeJson(groups), serializeJson(pool), createdAt, createdAt]
|
|
)
|
|
return findTierListById(nextId, authorId)
|
|
}
|
|
|
|
async function duplicateTierListForUser({ tierList, targetUserId }) {
|
|
const { nanoid } = require('nanoid')
|
|
const duplicateId = nanoid()
|
|
const baseTitle = (tierList.title || '티어표').trim() || '티어표'
|
|
const copyTitle = baseTitle.endsWith(' 복사본') ? baseTitle : `${baseTitle} 복사본`
|
|
return saveTierList({
|
|
id: duplicateId,
|
|
authorId: targetUserId,
|
|
topicId: tierList.topicId,
|
|
title: copyTitle,
|
|
thumbnailSrc: tierList.thumbnailSrc || '',
|
|
description: tierList.description || '',
|
|
isPublic: false,
|
|
showCharacterNames: !!tierList.showCharacterNames,
|
|
iconSize: Number(tierList.iconSize || 80),
|
|
sourceTierListId: tierList.id,
|
|
sourceSnapshotTitle: tierList.title || '',
|
|
sourceSnapshotAuthor: tierList.authorName || tierList.authorAccountName || '',
|
|
groups: JSON.parse(JSON.stringify(tierList.groups || [])),
|
|
pool: JSON.parse(JSON.stringify(tierList.pool || [])),
|
|
})
|
|
}
|
|
|
|
async function favoriteTierList({ userId, tierListId }) {
|
|
await query('INSERT IGNORE INTO favorite_tierlists (user_id, tierlist_id, created_at) VALUES (?, ?, ?)', [userId, tierListId, now()])
|
|
}
|
|
|
|
async function unfavoriteTierList({ userId, tierListId }) {
|
|
await query('DELETE FROM favorite_tierlists WHERE user_id = ? AND tierlist_id = ?', [userId, tierListId])
|
|
}
|
|
|
|
async function favoriteTopic({ userId, topicId }) {
|
|
await query('INSERT IGNORE INTO favorite_topics (user_id, topic_id, created_at) VALUES (?, ?, ?)', [userId, topicId, now()])
|
|
}
|
|
|
|
async function unfavoriteTopic({ userId, topicId }) {
|
|
await query('DELETE FROM favorite_topics WHERE user_id = ? AND topic_id = ?', [userId, topicId])
|
|
}
|
|
|
|
module.exports = {
|
|
DB_NAME,
|
|
ensureData,
|
|
closePool,
|
|
countUsers,
|
|
findUserByEmail,
|
|
findUserByNickname,
|
|
findUserById,
|
|
findUserProfileById,
|
|
createUser,
|
|
touchUserLastLoginAt,
|
|
updateUserPassword,
|
|
verifyUserEmail,
|
|
createEmailVerificationToken,
|
|
findEmailVerificationTokenByHash,
|
|
consumeEmailVerificationToken,
|
|
createPasswordResetToken,
|
|
findPasswordResetTokenByHash,
|
|
consumePasswordResetToken,
|
|
updateUserProfile,
|
|
findPrimaryAdminUser,
|
|
listUsers,
|
|
adminUpdateUser,
|
|
adminUpdateUserPassword,
|
|
adminDeleteUser,
|
|
listTopics,
|
|
findTopicById,
|
|
findTopicBySlug,
|
|
findTopicByIdentifier,
|
|
listTopicItems,
|
|
findTopicItemById,
|
|
getTopicDetail,
|
|
createTopic,
|
|
updateTopicMeta,
|
|
updateTopicThumbnail,
|
|
updateTopicVisibility,
|
|
findImageAssetByHash,
|
|
findImageAssetBySrc,
|
|
findImageAssetById,
|
|
updateImageAssetSrc,
|
|
createImageAsset,
|
|
createImageOptimizationJob,
|
|
findImageOptimizationJobById,
|
|
updateImageOptimizationJobStatus,
|
|
listRecentImageOptimizationJobs,
|
|
listUnusedImageAssets,
|
|
deleteImageAssets,
|
|
listImageAssets,
|
|
listReferencedUploadSources,
|
|
listReferencedUploadUsage,
|
|
replaceUploadSourceReferences,
|
|
updateCustomItemDisplayReferences,
|
|
clearImageOptimizationJobs,
|
|
getImageAssetStats,
|
|
cleanupMissingUploadReferences,
|
|
createTopicItem,
|
|
updateTopicItemLabel,
|
|
updateTopicItemMeta,
|
|
updateTopicItemDisplayOrder,
|
|
countTierListsUsingTopicItem,
|
|
deleteTopicItem,
|
|
deleteTopic,
|
|
updateTopicDisplayOrder,
|
|
updateCustomItemLabel,
|
|
updateCustomItemMeta,
|
|
clearCustomItemReplacement,
|
|
markCustomItemReplaced,
|
|
updateImageAssetLabel,
|
|
createCustomItem,
|
|
findCustomItemById,
|
|
listCustomItems,
|
|
findUnusedCustomItems,
|
|
listPublicTierLists,
|
|
listPublicTierListsByAuthor,
|
|
listFollowingTierLists,
|
|
listFavoriteTierLists,
|
|
listUserTierLists,
|
|
listAdminTierLists,
|
|
summarizeAdminTierLists,
|
|
findTierListById,
|
|
updateAdminTierListMeta,
|
|
updateTierListFeaturedStatus,
|
|
favoriteTopic,
|
|
unfavoriteTopic,
|
|
listTierListComments,
|
|
findTierListCommentById,
|
|
createTierListComment,
|
|
deleteTierListComment,
|
|
createCommentNotificationsForComment,
|
|
listCommentNotifications,
|
|
countUnreadCommentNotifications,
|
|
markCommentNotificationsRead,
|
|
followUser,
|
|
unfollowUser,
|
|
favoriteTierList,
|
|
unfavoriteTierList,
|
|
deleteTierList,
|
|
findCustomItemsByIds,
|
|
deleteCustomItems,
|
|
saveTierList,
|
|
duplicateTierListForUser,
|
|
createTemplateRequest,
|
|
findTemplateRequestById,
|
|
listAdminTemplateRequests,
|
|
updateTemplateRequestStatus,
|
|
updateTemplateRequestTargetTopic,
|
|
}
|