1975 lines
56 KiB
JavaScript
1975 lines
56 KiB
JavaScript
import {
|
|
getSamplePageBySlug,
|
|
getSamplePages,
|
|
getSamplePostBySlug,
|
|
getSamplePosts,
|
|
getSampleTags
|
|
} from '../utils/sample-content'
|
|
import { getDefaultNavigationItems } from '../utils/navigation-items'
|
|
import { buildPublicPrimaryTree, orderNavigationItemsForInsert } from '../utils/navigation-tree'
|
|
import { getDefaultSiteSettings } from '../utils/site-settings'
|
|
import { toAdminPostFormTitle } from '../../lib/admin-post-title.js'
|
|
import {
|
|
DEFAULT_ANNOUNCEMENT_ALIGNMENT,
|
|
DEFAULT_ANNOUNCEMENT_BACKGROUND_COLOR,
|
|
normalizeAnnouncementAlignment,
|
|
normalizeAnnouncementBackgroundColor
|
|
} from '../../lib/announcement-bar.js'
|
|
import { DEFAULT_BRAND_COLOR, normalizeBrandColor } from '../../lib/brand-color.js'
|
|
import {
|
|
normalizeSignupBlockedUsernames,
|
|
parseSignupBlockedUsernamesFromDb
|
|
} from '../../lib/signup-blocked-usernames.js'
|
|
import { normalizePostTagLimit } from '../../lib/post-tag-limit.js'
|
|
import {
|
|
DEFAULT_FEATURED_POST_LIMIT,
|
|
DEFAULT_HOME_LATEST_POST_LIMIT,
|
|
DEFAULT_PAGE_SECTION_ITEM_LIMIT,
|
|
DEFAULT_POST_LIST_PAGE_SIZE,
|
|
DEFAULT_TAG_POST_LIST_PAGE_SIZE,
|
|
normalizeDisplayCount
|
|
} from '../../lib/display-count-settings.js'
|
|
import {
|
|
normalizeUploadMaxFileCount,
|
|
normalizeUploadMaxTotalSize
|
|
} from '../../lib/upload-size-limit.js'
|
|
import { normalizeSocialLinks } from '../../lib/social-links.js'
|
|
import {
|
|
createPageCoverThumbnailForImageUrl,
|
|
createPostBodyThumbnailsForContent,
|
|
createPostThumbnailForImageUrl,
|
|
getExistingPageCoverThumbnailUrl,
|
|
getExistingPostThumbnailUrl
|
|
} from '../utils/post-thumbnail-image.js'
|
|
import { getPostgresClient } from './postgres-client'
|
|
|
|
/**
|
|
* 게시물 행을 API 응답 구조로 변환
|
|
* @param {Object} row - 게시물 행
|
|
* @returns {Object} 게시물 응답
|
|
*/
|
|
const mapPostRow = (row) => ({
|
|
id: row.id,
|
|
title: row.title,
|
|
slug: row.slug,
|
|
authorId: row.author_id || null,
|
|
content: row.content,
|
|
excerpt: row.excerpt,
|
|
featuredImage: row.featured_image,
|
|
featuredImageThumbnail: getExistingPostThumbnailUrl(row.featured_image),
|
|
showFeaturedImage: Boolean(row.show_featured_image),
|
|
isFeatured: Boolean(row.is_featured),
|
|
commentCount: Number(row.comment_count || 0),
|
|
totalViews: Number(row.total_views || 0),
|
|
seoTitle: row.seo_title || '',
|
|
seoDescription: row.seo_description || '',
|
|
canonicalUrl: row.canonical_url || '',
|
|
noindex: Boolean(row.noindex),
|
|
ogImage: row.og_image || null,
|
|
status: row.status,
|
|
publishedAt: row.published_at ? row.published_at.toISOString() : null,
|
|
createdAt: row.created_at.toISOString(),
|
|
updatedAt: row.updated_at.toISOString(),
|
|
tags: row.tags || []
|
|
})
|
|
|
|
/**
|
|
* 관리자 API용 게시물 행 변환(제목 없음 플레이스홀더는 빈 문자열)
|
|
* @param {Object} row - 게시물 행
|
|
* @returns {Object} 게시물 응답
|
|
*/
|
|
const mapAdminPostRow = (row) => ({
|
|
...mapPostRow(row),
|
|
title: toAdminPostFormTitle(row.title)
|
|
})
|
|
|
|
/**
|
|
* 고정 페이지 행을 API 응답 구조로 변환
|
|
* @param {Object} row - 고정 페이지 행
|
|
* @returns {Object} 고정 페이지 응답
|
|
*/
|
|
const mapPageRow = (row) => ({
|
|
id: row.id,
|
|
title: row.title,
|
|
slug: row.slug,
|
|
content: row.content,
|
|
renderMode: row.render_mode || 'markdown',
|
|
status: row.status || 'published',
|
|
featuredImage: row.featured_image,
|
|
listingImageThumbnail: getExistingPageCoverThumbnailUrl(row.featured_image),
|
|
isListed: Boolean(row.is_listed),
|
|
isFeatured: Boolean(row.is_featured),
|
|
listingSection: row.listing_section || '',
|
|
listingTitle: row.listing_title || '',
|
|
listingDescription: row.listing_description || '',
|
|
listingSortOrder: Number(row.listing_sort_order || 0),
|
|
totalViews: Number(row.total_views || 0),
|
|
createdAt: row.created_at.toISOString(),
|
|
updatedAt: row.updated_at.toISOString()
|
|
})
|
|
|
|
/**
|
|
* 페이지 섹션 행을 API 응답 구조로 변환
|
|
* @param {Object} row - 페이지 섹션 행
|
|
* @returns {Object} 페이지 섹션 응답
|
|
*/
|
|
const mapPageSectionRow = (row) => ({
|
|
id: row.id,
|
|
name: row.name,
|
|
sortOrder: Number(row.sort_order || 0),
|
|
pageCount: Number(row.page_count || 0),
|
|
createdAt: row.created_at.toISOString(),
|
|
updatedAt: row.updated_at.toISOString()
|
|
})
|
|
|
|
/**
|
|
* 태그 행을 API 응답 구조로 변환
|
|
* @param {Object} row - 태그 행
|
|
* @returns {Object} 태그 응답
|
|
*/
|
|
const mapTagRow = (row) => ({
|
|
id: row.id,
|
|
name: row.name,
|
|
slug: row.slug,
|
|
description: row.description,
|
|
headerImageUrl: row.header_image_url || '',
|
|
headerTitle: row.header_title || '',
|
|
headerText: row.header_text || '',
|
|
sortOrder: row.sort_order,
|
|
color: row.color,
|
|
tagType: row.tag_type || 'managed',
|
|
postCount: Number(row.post_count || 0),
|
|
lastUsedAt: row.last_used_at ? row.last_used_at.toISOString() : null,
|
|
updatedAt: row.updated_at ? row.updated_at.toISOString() : null
|
|
})
|
|
|
|
/**
|
|
* 사이트 설정 행을 API 응답 구조로 변환
|
|
* @param {Object} row - 사이트 설정 행
|
|
* @returns {Object} 사이트 설정 응답
|
|
*/
|
|
const mapSiteSettingsRow = (row) => ({
|
|
title: row.title,
|
|
description: row.description,
|
|
siteUrl: row.site_url,
|
|
logoText: row.logo_text,
|
|
logoUrl: row.logo_url || '',
|
|
faviconUrl: row.favicon_url || '',
|
|
copyrightText: row.copyright_text,
|
|
socialLinks: normalizeSocialLinks(row.social_links),
|
|
showPostUpdatedAt: Boolean(row.show_post_updated_at),
|
|
postTagLimit: normalizePostTagLimit(row.post_tag_limit),
|
|
homeLatestPostLimit: normalizeDisplayCount(row.home_latest_post_limit, DEFAULT_HOME_LATEST_POST_LIMIT),
|
|
postListPageSize: normalizeDisplayCount(row.post_list_page_size, DEFAULT_POST_LIST_PAGE_SIZE),
|
|
tagPostListPageSize: normalizeDisplayCount(row.tag_post_list_page_size, DEFAULT_TAG_POST_LIST_PAGE_SIZE),
|
|
featuredPostLimit: normalizeDisplayCount(row.featured_post_limit, DEFAULT_FEATURED_POST_LIMIT),
|
|
pageSectionItemLimit: normalizeDisplayCount(row.page_section_item_limit, DEFAULT_PAGE_SECTION_ITEM_LIMIT),
|
|
uploadMaxFileCount: normalizeUploadMaxFileCount(row.upload_max_file_count),
|
|
uploadMaxTotalSize: normalizeUploadMaxTotalSize(row.upload_max_total_size),
|
|
homeCoverImageUrl: row.home_cover_image_url || '',
|
|
homeCoverDarkImageUrl: row.home_cover_dark_image_url || '',
|
|
homeCoverTitle: row.home_cover_title || '',
|
|
homeCoverText: row.home_cover_text || '',
|
|
brandColor: normalizeBrandColor(row.brand_color || DEFAULT_BRAND_COLOR),
|
|
announcementEnabled: Boolean(row.announcement_enabled),
|
|
announcementText: row.announcement_text || '',
|
|
announcementUrl: row.announcement_url || '',
|
|
announcementBackgroundColor: normalizeAnnouncementBackgroundColor(row.announcement_background_color || DEFAULT_ANNOUNCEMENT_BACKGROUND_COLOR),
|
|
announcementAlignment: normalizeAnnouncementAlignment(row.announcement_alignment || DEFAULT_ANNOUNCEMENT_ALIGNMENT),
|
|
signupBlockedUsernames: parseSignupBlockedUsernamesFromDb(row.signup_blocked_usernames),
|
|
adsTxt: row.ads_txt || '',
|
|
customHeadCode: row.custom_head_code || '',
|
|
customFooterCode: row.custom_footer_code || '',
|
|
adHomeFeedCode: row.ad_home_feed_code || '',
|
|
adHomeInfeedCode: row.ad_home_infeed_code || '',
|
|
adSidebarCode: row.ad_sidebar_code || '',
|
|
adPostSidebarCode: row.ad_post_sidebar_code || '',
|
|
adPostTopCode: row.ad_post_top_code || '',
|
|
adPostInArticleCode: row.ad_post_in_article_code || '',
|
|
adPostBottomCode: row.ad_post_bottom_code || '',
|
|
updatedAt: row.updated_at.toISOString()
|
|
})
|
|
|
|
/**
|
|
* 네비게이션 행을 API 응답 구조로 변환
|
|
* @param {Object} row - 네비게이션 행
|
|
* @returns {Object} 네비게이션 응답
|
|
*/
|
|
const mapNavigationItemRow = (row) => ({
|
|
id: row.id,
|
|
label: row.label,
|
|
url: row.url,
|
|
descriptionText: row.description_text || '',
|
|
thumbnailUrl: row.thumbnail_url || '',
|
|
cachedFaviconUrl: row.cached_favicon_url || '',
|
|
faviconCachedAt: row.favicon_cached_at ? row.favicon_cached_at.toISOString() : '',
|
|
location: row.location,
|
|
sortOrder: row.sort_order,
|
|
isVisible: row.is_visible,
|
|
parentId: row.parent_id ?? null,
|
|
isFolder: Boolean(row.is_folder),
|
|
createdAt: row.created_at.toISOString(),
|
|
updatedAt: row.updated_at.toISOString()
|
|
})
|
|
|
|
/**
|
|
* 태그 슬러그 목록 정규화
|
|
* @param {Array<string>} tags - 태그 슬러그 목록
|
|
* @returns {Array<string>} 정규화된 태그 슬러그 목록
|
|
*/
|
|
const normalizeTagSlugs = (tags = []) => {
|
|
const seen = new Set()
|
|
const out = []
|
|
|
|
for (const tag of tags) {
|
|
const normalized = String(tag)
|
|
.trim()
|
|
.normalize('NFC')
|
|
.toLowerCase()
|
|
.replace(/[\\/]+/g, '-')
|
|
.replace(/\s+/g, '-')
|
|
.replace(/[^a-z0-9가-힣-]+/g, '')
|
|
.replace(/-+/g, '-')
|
|
.replace(/^-|-$/g, '')
|
|
if (!normalized) {
|
|
continue
|
|
}
|
|
const dedupeKey = normalized.toLowerCase()
|
|
if (seen.has(dedupeKey)) {
|
|
continue
|
|
}
|
|
seen.add(dedupeKey)
|
|
out.push(normalized)
|
|
}
|
|
|
|
return out
|
|
}
|
|
|
|
/**
|
|
* 태그 슬러그를 표시용 태그명으로 변환
|
|
* @param {string} slug - 태그 슬러그
|
|
* @returns {string} 태그명
|
|
*/
|
|
const getTagNameFromSlug = (slug) => {
|
|
const trimmed = String(slug).trim()
|
|
if (!trimmed) {
|
|
return ''
|
|
}
|
|
if (/[가-힣]/.test(trimmed)) {
|
|
return trimmed.split('-').filter(Boolean).join(' ')
|
|
}
|
|
|
|
return trimmed
|
|
.split('-')
|
|
.filter(Boolean)
|
|
.map((word) => `${word.charAt(0).toUpperCase()}${word.slice(1)}`)
|
|
.join(' ')
|
|
}
|
|
|
|
/**
|
|
* 새 태그 표시 이름을 정리한다.
|
|
* @param {string} value - 원본 표시 이름
|
|
* @returns {string} 표시 이름
|
|
*/
|
|
const normalizeTagDisplayName = (value) => String(value || '')
|
|
.normalize('NFC')
|
|
.trim()
|
|
.replace(/\s*\/\s*/g, '/')
|
|
.replace(/\s+/g, ' ')
|
|
|
|
/**
|
|
* 태그 슬러그에 대응하는 표시 이름을 반환한다.
|
|
* @param {string} slug - 태그 슬러그
|
|
* @param {Object} tagNames - 태그 표시 이름 맵
|
|
* @returns {string} 태그명
|
|
*/
|
|
const resolveTagName = (slug, tagNames = {}) => {
|
|
const inputName = normalizeTagDisplayName(tagNames[slug])
|
|
return inputName || getTagNameFromSlug(slug)
|
|
}
|
|
|
|
/**
|
|
* 게시물 태그 연결 저장
|
|
* @param {Function} sql - PostgreSQL 트랜잭션 클라이언트
|
|
* @param {string} postId - 게시물 ID
|
|
* @param {Array<string>} tags - 태그 슬러그 목록
|
|
* @param {Object} tagNames - 태그 표시 이름 맵
|
|
* @returns {Promise<void>} 저장 결과
|
|
*/
|
|
const syncPostTags = async (sql, postId, tags, tagNames = {}) => {
|
|
const tagSlugs = normalizeTagSlugs(tags)
|
|
|
|
await sql`
|
|
DELETE FROM post_tags
|
|
WHERE post_id = ${postId}
|
|
`
|
|
|
|
for (const [index, slug] of tagSlugs.entries()) {
|
|
const tagRows = await sql`
|
|
INSERT INTO tags (name, slug, tag_type, sort_order)
|
|
VALUES (${resolveTagName(slug, tagNames)}, ${slug}, 'general', 0)
|
|
ON CONFLICT (slug) DO UPDATE
|
|
SET updated_at = now()
|
|
RETURNING id
|
|
`
|
|
|
|
await sql`
|
|
INSERT INTO post_tags (post_id, tag_id, sort_order)
|
|
VALUES (${postId}, ${tagRows[0].id}, ${index * 10})
|
|
ON CONFLICT (post_id, tag_id) DO UPDATE
|
|
SET sort_order = EXCLUDED.sort_order
|
|
`
|
|
}
|
|
}
|
|
|
|
/**
|
|
* 공개 게시물 목록 조회
|
|
* @param {{ includeMembership?: boolean, limit?: number|null, offset?: number, tagSlug?: string, featuredOnly?: boolean, includeTotal?: boolean }} [options] - 조회 옵션
|
|
* @returns {Promise<Array|{ items: Array, total: number }>} 게시물 목록
|
|
*/
|
|
export const listPosts = async ({
|
|
includeMembership = false,
|
|
limit = null,
|
|
offset = 0,
|
|
tagSlug = '',
|
|
featuredOnly = false,
|
|
includeTotal = false
|
|
} = {}) => {
|
|
const sql = getPostgresClient()
|
|
const resolvedLimit = Number.isInteger(limit) && limit > 0 ? limit : null
|
|
const resolvedOffset = Number.isInteger(offset) && offset > 0 ? offset : 0
|
|
const normalizedTagSlug = String(tagSlug || '').trim()
|
|
|
|
if (!sql) {
|
|
let samplePosts = getSamplePosts()
|
|
if (featuredOnly) {
|
|
samplePosts = samplePosts.filter((post) => Boolean(post.isFeatured))
|
|
}
|
|
if (normalizedTagSlug) {
|
|
samplePosts = samplePosts.filter((post) => post.tags.includes(normalizedTagSlug))
|
|
}
|
|
const total = samplePosts.length
|
|
const items = resolvedLimit
|
|
? samplePosts.slice(resolvedOffset, resolvedOffset + resolvedLimit)
|
|
: samplePosts
|
|
|
|
return includeTotal ? { items, total } : items
|
|
}
|
|
|
|
const rows = await sql`
|
|
SELECT
|
|
posts.*,
|
|
(
|
|
SELECT COUNT(*)::int
|
|
FROM comments
|
|
WHERE comments.post_id = posts.id
|
|
AND comments.status = 'published'
|
|
) AS comment_count,
|
|
(
|
|
SELECT COALESCE(SUM(post_analytics_daily.views), 0)::int
|
|
FROM post_analytics_daily
|
|
WHERE post_analytics_daily.post_id = posts.id
|
|
) AS total_views,
|
|
COALESCE(array_agg(tags.slug ORDER BY post_tags.sort_order ASC, post_tags.created_at ASC, tags.name ASC) FILTER (WHERE tags.slug IS NOT NULL), '{}') AS tags
|
|
FROM posts
|
|
LEFT JOIN post_tags ON post_tags.post_id = posts.id
|
|
LEFT JOIN tags ON tags.id = post_tags.tag_id
|
|
WHERE (
|
|
posts.status = 'published'
|
|
OR (${includeMembership} = true AND posts.status = 'members')
|
|
)
|
|
AND (
|
|
posts.status = 'members'
|
|
OR posts.published_at IS NULL
|
|
OR posts.published_at <= now()
|
|
)
|
|
AND (${featuredOnly} = false OR posts.is_featured = true)
|
|
AND (
|
|
${normalizedTagSlug || null}::text IS NULL
|
|
OR EXISTS (
|
|
SELECT 1
|
|
FROM post_tags tagged_post_tags
|
|
INNER JOIN tags tagged_tags ON tagged_tags.id = tagged_post_tags.tag_id
|
|
WHERE tagged_post_tags.post_id = posts.id
|
|
AND tagged_tags.slug = ${normalizedTagSlug || null}
|
|
)
|
|
)
|
|
GROUP BY posts.id
|
|
ORDER BY posts.published_at DESC NULLS LAST, posts.created_at DESC
|
|
LIMIT ${resolvedLimit || 2147483647}
|
|
OFFSET ${resolvedOffset}
|
|
`
|
|
|
|
const items = rows.map(mapPostRow)
|
|
|
|
if (!includeTotal) {
|
|
return items
|
|
}
|
|
|
|
const totalRows = await sql`
|
|
SELECT COUNT(*)::int AS total
|
|
FROM posts
|
|
WHERE (
|
|
posts.status = 'published'
|
|
OR (${includeMembership} = true AND posts.status = 'members')
|
|
)
|
|
AND (
|
|
posts.status = 'members'
|
|
OR posts.published_at IS NULL
|
|
OR posts.published_at <= now()
|
|
)
|
|
AND (${featuredOnly} = false OR posts.is_featured = true)
|
|
AND (
|
|
${normalizedTagSlug || null}::text IS NULL
|
|
OR EXISTS (
|
|
SELECT 1
|
|
FROM post_tags tagged_post_tags
|
|
INNER JOIN tags tagged_tags ON tagged_tags.id = tagged_post_tags.tag_id
|
|
WHERE tagged_post_tags.post_id = posts.id
|
|
AND tagged_tags.slug = ${normalizedTagSlug || null}
|
|
)
|
|
)
|
|
`
|
|
|
|
return {
|
|
items,
|
|
total: Number(totalRows[0]?.total || 0)
|
|
}
|
|
}
|
|
|
|
/**
|
|
* 관리자 게시물 목록 조회
|
|
* @returns {Promise<Array>} 관리자 게시물 목록
|
|
*/
|
|
export const listAdminPosts = async () => {
|
|
const sql = getPostgresClient()
|
|
|
|
if (!sql) {
|
|
return getSamplePosts()
|
|
}
|
|
|
|
const rows = await sql`
|
|
SELECT
|
|
posts.*,
|
|
(
|
|
SELECT COUNT(*)::int
|
|
FROM comments
|
|
WHERE comments.post_id = posts.id
|
|
AND comments.status = 'published'
|
|
) AS comment_count,
|
|
(
|
|
SELECT COALESCE(SUM(post_analytics_daily.views), 0)::int
|
|
FROM post_analytics_daily
|
|
WHERE post_analytics_daily.post_id = posts.id
|
|
) AS total_views,
|
|
COALESCE(array_agg(tags.slug ORDER BY post_tags.sort_order ASC, post_tags.created_at ASC, tags.name ASC) FILTER (WHERE tags.slug IS NOT NULL), '{}') AS tags
|
|
FROM posts
|
|
LEFT JOIN post_tags ON post_tags.post_id = posts.id
|
|
LEFT JOIN tags ON tags.id = post_tags.tag_id
|
|
GROUP BY posts.id
|
|
ORDER BY COALESCE(posts.published_at, posts.updated_at) DESC
|
|
`
|
|
|
|
return rows.map(mapAdminPostRow)
|
|
}
|
|
|
|
/**
|
|
* 관리자 게시물 상세 조회
|
|
* @param {string} id - 게시물 ID
|
|
* @returns {Promise<Object | null>} 관리자 게시물 상세
|
|
*/
|
|
export const getAdminPostById = async (id) => {
|
|
const sql = getPostgresClient()
|
|
|
|
if (!sql) {
|
|
return getSamplePosts().find((post) => post.id === id) || null
|
|
}
|
|
|
|
const rows = await sql`
|
|
SELECT
|
|
posts.*,
|
|
(
|
|
SELECT COUNT(*)::int
|
|
FROM comments
|
|
WHERE comments.post_id = posts.id
|
|
AND comments.status = 'published'
|
|
) AS comment_count,
|
|
COALESCE(array_agg(tags.slug ORDER BY post_tags.sort_order ASC, post_tags.created_at ASC, tags.name ASC) FILTER (WHERE tags.slug IS NOT NULL), '{}') AS tags
|
|
FROM posts
|
|
LEFT JOIN post_tags ON post_tags.post_id = posts.id
|
|
LEFT JOIN tags ON tags.id = post_tags.tag_id
|
|
WHERE posts.id = ${id}
|
|
GROUP BY posts.id
|
|
LIMIT 1
|
|
`
|
|
|
|
return rows[0] ? mapAdminPostRow(rows[0]) : null
|
|
}
|
|
|
|
/**
|
|
* 관리자 게시물 생성
|
|
* @param {Object} input - 게시물 입력값
|
|
* @param {string} authorId - 작성자 회원 ID
|
|
* @returns {Promise<Object>} 생성된 게시물
|
|
*/
|
|
export const createAdminPost = async (input, authorId) => {
|
|
const sql = getPostgresClient()
|
|
|
|
if (!sql) {
|
|
throw new Error('DATABASE_REQUIRED')
|
|
}
|
|
|
|
const rows = await sql.begin(async (transaction) => {
|
|
const insertedRows = await transaction`
|
|
INSERT INTO posts (
|
|
title,
|
|
slug,
|
|
author_id,
|
|
content,
|
|
excerpt,
|
|
featured_image,
|
|
show_featured_image,
|
|
is_featured,
|
|
seo_title,
|
|
seo_description,
|
|
canonical_url,
|
|
noindex,
|
|
og_image,
|
|
status,
|
|
published_at
|
|
)
|
|
VALUES (
|
|
${input.title},
|
|
${input.slug},
|
|
${authorId || null},
|
|
${input.content},
|
|
${input.excerpt},
|
|
${input.featuredImage},
|
|
${input.showFeaturedImage},
|
|
${input.isFeatured},
|
|
${input.seoTitle},
|
|
${input.seoDescription},
|
|
${input.canonicalUrl},
|
|
${input.noindex},
|
|
${input.ogImage},
|
|
${input.status},
|
|
${input.publishedAt}
|
|
)
|
|
RETURNING *
|
|
`
|
|
|
|
await syncPostTags(transaction, insertedRows[0].id, input.tags, input.tagNames)
|
|
|
|
return insertedRows
|
|
})
|
|
|
|
await Promise.all([
|
|
createPostThumbnailForImageUrl(input.featuredImage),
|
|
createPostBodyThumbnailsForContent(input.content)
|
|
])
|
|
|
|
return getAdminPostById(rows[0].id)
|
|
}
|
|
|
|
/**
|
|
* 관리자 게시물 수정
|
|
* @param {string} id - 게시물 ID
|
|
* @param {Object} input - 게시물 입력값
|
|
* @param {string} editorId - 수정자 회원 ID
|
|
* @returns {Promise<Object | null>} 수정된 게시물
|
|
*/
|
|
export const updateAdminPost = async (id, input, editorId) => {
|
|
const sql = getPostgresClient()
|
|
|
|
if (!sql) {
|
|
throw new Error('DATABASE_REQUIRED')
|
|
}
|
|
|
|
const rows = await sql.begin(async (transaction) => {
|
|
const updatedRows = await transaction`
|
|
UPDATE posts
|
|
SET
|
|
title = ${input.title},
|
|
slug = ${input.slug},
|
|
author_id = COALESCE(author_id, ${editorId || null}),
|
|
content = ${input.content},
|
|
excerpt = ${input.excerpt},
|
|
featured_image = ${input.featuredImage},
|
|
show_featured_image = ${input.showFeaturedImage},
|
|
is_featured = ${input.isFeatured},
|
|
seo_title = ${input.seoTitle},
|
|
seo_description = ${input.seoDescription},
|
|
canonical_url = ${input.canonicalUrl},
|
|
noindex = ${input.noindex},
|
|
og_image = ${input.ogImage},
|
|
status = ${input.status},
|
|
published_at = ${input.publishedAt},
|
|
updated_at = now()
|
|
WHERE id = ${id}
|
|
RETURNING *
|
|
`
|
|
|
|
if (!updatedRows[0]) {
|
|
return []
|
|
}
|
|
|
|
await syncPostTags(transaction, id, input.tags, input.tagNames)
|
|
|
|
return updatedRows
|
|
})
|
|
|
|
if (rows[0]) {
|
|
await Promise.all([
|
|
createPostThumbnailForImageUrl(input.featuredImage),
|
|
createPostBodyThumbnailsForContent(input.content)
|
|
])
|
|
}
|
|
|
|
return rows[0] ? getAdminPostById(rows[0].id) : null
|
|
}
|
|
|
|
/**
|
|
* 관리자 게시물 삭제
|
|
* @param {string} id - 게시물 ID
|
|
* @returns {Promise<boolean>} 삭제 여부
|
|
*/
|
|
export const deleteAdminPost = async (id) => {
|
|
const sql = getPostgresClient()
|
|
|
|
if (!sql) {
|
|
throw new Error('DATABASE_REQUIRED')
|
|
}
|
|
|
|
const rows = await sql`
|
|
DELETE FROM posts
|
|
WHERE id = ${id}
|
|
RETURNING id
|
|
`
|
|
|
|
return Boolean(rows[0])
|
|
}
|
|
|
|
/**
|
|
* 공개 게시물 상세 조회
|
|
* @param {string} slug - 게시물 슬러그
|
|
* @param {{ includeMembership?: boolean }} [options] - VIP 전용 글 포함 여부
|
|
* @returns {Promise<Object | null>} 게시물 상세
|
|
*/
|
|
export const getPostBySlug = async (slug, { includeMembership = false } = {}) => {
|
|
const sql = getPostgresClient()
|
|
|
|
if (!sql) {
|
|
return getSamplePostBySlug(slug)
|
|
}
|
|
|
|
const rows = await sql`
|
|
SELECT
|
|
posts.*,
|
|
(
|
|
SELECT COUNT(*)::int
|
|
FROM comments
|
|
WHERE comments.post_id = posts.id
|
|
AND comments.status = 'published'
|
|
) AS comment_count,
|
|
COALESCE(array_agg(tags.slug ORDER BY post_tags.sort_order ASC, post_tags.created_at ASC, tags.name ASC) FILTER (WHERE tags.slug IS NOT NULL), '{}') AS tags
|
|
FROM posts
|
|
LEFT JOIN post_tags ON post_tags.post_id = posts.id
|
|
LEFT JOIN tags ON tags.id = post_tags.tag_id
|
|
WHERE posts.slug = ${slug}
|
|
AND (
|
|
posts.status = 'published'
|
|
OR (${includeMembership} = true AND posts.status = 'members')
|
|
)
|
|
AND (
|
|
posts.status = 'members'
|
|
OR posts.published_at IS NULL
|
|
OR posts.published_at <= now()
|
|
)
|
|
GROUP BY posts.id
|
|
LIMIT 1
|
|
`
|
|
|
|
return rows[0] ? mapPostRow(rows[0]) : null
|
|
}
|
|
|
|
/**
|
|
* 공개 고정 페이지 목록 조회
|
|
* @param {{ listedOnly?: boolean, limitPerSection?: number|null }} [options] - 조회 옵션
|
|
* @returns {Promise<Array>} 고정 페이지 목록
|
|
*/
|
|
export const listPages = async (options = {}) => {
|
|
const sql = getPostgresClient()
|
|
const listedOnly = Boolean(options.listedOnly)
|
|
const limitPerSection = Number.isInteger(options.limitPerSection) && options.limitPerSection > 0
|
|
? options.limitPerSection
|
|
: null
|
|
|
|
if (!sql) {
|
|
const pages = getSamplePages().filter((page) => page.status === 'published')
|
|
if (!listedOnly) {
|
|
return pages
|
|
}
|
|
|
|
const sectionCounts = new Map()
|
|
return pages
|
|
.filter((page) => page.isListed)
|
|
.filter((page) => {
|
|
if (!limitPerSection) {
|
|
return true
|
|
}
|
|
const sectionName = String(page.listingSection || '').trim() || 'Pages'
|
|
const count = Number(sectionCounts.get(sectionName) || 0) + 1
|
|
sectionCounts.set(sectionName, count)
|
|
return count <= limitPerSection
|
|
})
|
|
.map((page) => ({ ...page, content: '' }))
|
|
}
|
|
|
|
if (listedOnly) {
|
|
const rows = await sql`
|
|
SELECT *
|
|
FROM (
|
|
SELECT
|
|
pages.id,
|
|
pages.title,
|
|
pages.slug,
|
|
'' AS content,
|
|
pages.render_mode,
|
|
pages.status,
|
|
pages.featured_image,
|
|
pages.is_listed,
|
|
pages.is_featured,
|
|
pages.listing_section,
|
|
pages.listing_title,
|
|
pages.listing_description,
|
|
pages.listing_sort_order,
|
|
pages.created_at,
|
|
pages.updated_at,
|
|
COALESCE(page_listing_sections.sort_order, 9999) AS section_sort_order,
|
|
row_number() OVER (
|
|
PARTITION BY COALESCE(NULLIF(pages.listing_section, ''), 'Pages')
|
|
ORDER BY
|
|
pages.is_featured DESC,
|
|
pages.listing_sort_order ASC,
|
|
pages.updated_at DESC,
|
|
pages.created_at DESC
|
|
) AS section_row_number
|
|
FROM pages
|
|
LEFT JOIN page_listing_sections
|
|
ON page_listing_sections.name = pages.listing_section
|
|
WHERE pages.status = 'published'
|
|
AND pages.is_listed = true
|
|
) listed_pages
|
|
WHERE (${limitPerSection || null}::int IS NULL OR listed_pages.section_row_number <= ${limitPerSection || null})
|
|
ORDER BY
|
|
listed_pages.section_sort_order ASC,
|
|
listed_pages.listing_section ASC,
|
|
listed_pages.is_featured DESC,
|
|
listed_pages.listing_sort_order ASC,
|
|
listed_pages.updated_at DESC,
|
|
listed_pages.created_at DESC
|
|
`
|
|
|
|
return rows.map(mapPageRow)
|
|
}
|
|
|
|
const rows = await sql`
|
|
SELECT pages.*
|
|
FROM pages
|
|
LEFT JOIN page_listing_sections
|
|
ON page_listing_sections.name = pages.listing_section
|
|
WHERE status = 'published'
|
|
AND (${listedOnly} = false OR is_listed = true)
|
|
ORDER BY
|
|
COALESCE(page_listing_sections.sort_order, 9999) ASC,
|
|
listing_section ASC,
|
|
is_featured DESC,
|
|
listing_sort_order ASC,
|
|
updated_at DESC,
|
|
created_at DESC
|
|
`
|
|
|
|
return rows.map(mapPageRow)
|
|
}
|
|
|
|
/**
|
|
* 관리자 고정 페이지 목록 조회
|
|
* @returns {Promise<Array>} 관리자 고정 페이지 목록
|
|
*/
|
|
export const listAdminPages = async () => {
|
|
const sql = getPostgresClient()
|
|
|
|
if (!sql) {
|
|
return getSamplePages()
|
|
}
|
|
|
|
const rows = await sql`
|
|
SELECT
|
|
pages.*,
|
|
(
|
|
SELECT COALESCE(SUM(page_analytics_daily.views), 0)::int
|
|
FROM page_analytics_daily
|
|
WHERE page_analytics_daily.page_id = pages.id
|
|
) AS total_views
|
|
FROM pages
|
|
ORDER BY created_at DESC
|
|
`
|
|
|
|
return rows.map(mapPageRow)
|
|
}
|
|
|
|
/**
|
|
* 관리자 고정 페이지 상세 조회
|
|
* @param {string} id - 페이지 ID
|
|
* @returns {Promise<Object | null>} 관리자 고정 페이지 상세
|
|
*/
|
|
export const getAdminPageById = async (id) => {
|
|
const sql = getPostgresClient()
|
|
|
|
if (!sql) {
|
|
return getSamplePages().find((page) => page.id === id) || null
|
|
}
|
|
|
|
const rows = await sql`
|
|
SELECT *
|
|
FROM pages
|
|
WHERE id = ${id}
|
|
LIMIT 1
|
|
`
|
|
|
|
return rows[0] ? mapPageRow(rows[0]) : null
|
|
}
|
|
|
|
/**
|
|
* 관리자 페이지 섹션 목록 조회
|
|
* @returns {Promise<Array>} 페이지 섹션 목록
|
|
*/
|
|
export const listAdminPageSections = async () => {
|
|
const sql = getPostgresClient()
|
|
|
|
if (!sql) {
|
|
const sections = new Map()
|
|
for (const page of getSamplePages()) {
|
|
const name = String(page.listingSection || '').trim()
|
|
if (!name) {
|
|
continue
|
|
}
|
|
sections.set(name, {
|
|
id: `sample-page-section-${sections.size + 1}`,
|
|
name,
|
|
sortOrder: sections.size * 10,
|
|
pageCount: (sections.get(name)?.pageCount || 0) + 1,
|
|
createdAt: page.createdAt,
|
|
updatedAt: page.updatedAt
|
|
})
|
|
}
|
|
return [...sections.values()]
|
|
}
|
|
|
|
const rows = await sql`
|
|
SELECT
|
|
page_listing_sections.*,
|
|
(
|
|
SELECT COUNT(*)::int
|
|
FROM pages
|
|
WHERE pages.listing_section = page_listing_sections.name
|
|
) AS page_count
|
|
FROM page_listing_sections
|
|
ORDER BY sort_order ASC, name ASC
|
|
`
|
|
|
|
return rows.map(mapPageSectionRow)
|
|
}
|
|
|
|
/**
|
|
* 관리자 페이지 섹션 생성
|
|
* @param {string} name - 섹션명
|
|
* @returns {Promise<Object>} 생성된 페이지 섹션
|
|
*/
|
|
export const createAdminPageSection = async (name) => {
|
|
const sql = getPostgresClient()
|
|
|
|
if (!sql) {
|
|
throw new Error('DATABASE_REQUIRED')
|
|
}
|
|
|
|
const rows = await sql`
|
|
INSERT INTO page_listing_sections (name, sort_order)
|
|
VALUES (
|
|
${name},
|
|
COALESCE((SELECT MAX(sort_order) + 10 FROM page_listing_sections), 0)
|
|
)
|
|
RETURNING *, 0::int AS page_count
|
|
`
|
|
|
|
return mapPageSectionRow(rows[0])
|
|
}
|
|
|
|
/**
|
|
* 관리자 페이지 섹션 수정
|
|
* @param {string} id - 섹션 ID
|
|
* @param {{ name: string }} input - 수정 입력값
|
|
* @returns {Promise<Object | null>} 수정된 페이지 섹션
|
|
*/
|
|
export const updateAdminPageSection = async (id, input) => {
|
|
const sql = getPostgresClient()
|
|
|
|
if (!sql) {
|
|
throw new Error('DATABASE_REQUIRED')
|
|
}
|
|
|
|
const currentRows = await sql`
|
|
SELECT *
|
|
FROM page_listing_sections
|
|
WHERE id = ${id}
|
|
LIMIT 1
|
|
`
|
|
|
|
if (!currentRows[0]) {
|
|
return null
|
|
}
|
|
|
|
await sql.begin(async (transaction) => {
|
|
await transaction`
|
|
UPDATE page_listing_sections
|
|
SET name = ${input.name}, updated_at = now()
|
|
WHERE id = ${id}
|
|
`
|
|
await transaction`
|
|
UPDATE pages
|
|
SET listing_section = ${input.name}, updated_at = now()
|
|
WHERE listing_section = ${currentRows[0].name}
|
|
`
|
|
})
|
|
|
|
const rows = await sql`
|
|
SELECT
|
|
page_listing_sections.*,
|
|
(
|
|
SELECT COUNT(*)::int
|
|
FROM pages
|
|
WHERE pages.listing_section = page_listing_sections.name
|
|
) AS page_count
|
|
FROM page_listing_sections
|
|
WHERE id = ${id}
|
|
LIMIT 1
|
|
`
|
|
|
|
return rows[0] ? mapPageSectionRow(rows[0]) : null
|
|
}
|
|
|
|
/**
|
|
* 관리자 페이지 섹션 삭제
|
|
* @param {string} id - 섹션 ID
|
|
* @returns {Promise<boolean>} 삭제 여부
|
|
*/
|
|
export const deleteAdminPageSection = async (id) => {
|
|
const sql = getPostgresClient()
|
|
|
|
if (!sql) {
|
|
throw new Error('DATABASE_REQUIRED')
|
|
}
|
|
|
|
const rows = await sql`
|
|
DELETE FROM page_listing_sections
|
|
WHERE id = ${id}
|
|
AND NOT EXISTS (
|
|
SELECT 1
|
|
FROM pages
|
|
WHERE pages.listing_section = page_listing_sections.name
|
|
)
|
|
RETURNING id
|
|
`
|
|
|
|
return Boolean(rows[0])
|
|
}
|
|
|
|
/**
|
|
* 관리자 페이지 섹션 정렬 저장
|
|
* @param {Array<string>} sectionIds - 섹션 ID 목록
|
|
* @returns {Promise<Array>} 정렬 저장 후 섹션 목록
|
|
*/
|
|
export const reorderAdminPageSections = async (sectionIds) => {
|
|
const sql = getPostgresClient()
|
|
|
|
if (!sql) {
|
|
throw new Error('DATABASE_REQUIRED')
|
|
}
|
|
|
|
await sql.begin(async (transaction) => {
|
|
for (const [index, sectionId] of sectionIds.entries()) {
|
|
await transaction`
|
|
UPDATE page_listing_sections
|
|
SET sort_order = ${index * 10}, updated_at = now()
|
|
WHERE id = ${sectionId}
|
|
`
|
|
}
|
|
})
|
|
|
|
return listAdminPageSections()
|
|
}
|
|
|
|
/**
|
|
* 관리자 페이지 섹션 내부 페이지 정렬 저장
|
|
* @param {string} sectionId - 페이지 섹션 ID
|
|
* @param {Array<string>} pageIds - 정렬할 페이지 ID 목록
|
|
* @param {Array<string>} removedPageIds - 섹션에서 제거할 페이지 ID 목록
|
|
* @returns {Promise<Array>} 정렬 저장 후 페이지 목록
|
|
*/
|
|
export const reorderAdminPageSectionPages = async (sectionId, pageIds, removedPageIds = []) => {
|
|
const sql = getPostgresClient()
|
|
|
|
if (!sql) {
|
|
throw new Error('DATABASE_REQUIRED')
|
|
}
|
|
|
|
const sectionRows = await sql`
|
|
SELECT *
|
|
FROM page_listing_sections
|
|
WHERE id = ${sectionId}
|
|
LIMIT 1
|
|
`
|
|
|
|
if (!sectionRows[0]) {
|
|
return null
|
|
}
|
|
|
|
const removedIdSet = new Set(removedPageIds.map((id) => String(id)))
|
|
const nextPageIds = [...new Set(pageIds.map((id) => String(id)).filter((id) => !removedIdSet.has(id)))]
|
|
const nextRemovedPageIds = [...removedIdSet]
|
|
const targetPageIds = [...new Set([...nextPageIds, ...nextRemovedPageIds])]
|
|
|
|
if (targetPageIds.length === 0) {
|
|
return listAdminPages()
|
|
}
|
|
|
|
const pageRows = await sql`
|
|
SELECT id
|
|
FROM pages
|
|
WHERE listing_section = ${sectionRows[0].name}
|
|
AND is_listed = true
|
|
AND id = ANY(${targetPageIds})
|
|
`
|
|
|
|
if (pageRows.length !== targetPageIds.length) {
|
|
throw new Error('PAGE_SECTION_PAGE_MISMATCH')
|
|
}
|
|
|
|
await sql.begin(async (transaction) => {
|
|
if (nextRemovedPageIds.length > 0) {
|
|
await transaction`
|
|
UPDATE pages
|
|
SET listing_section = '', listing_sort_order = 0, updated_at = now()
|
|
WHERE listing_section = ${sectionRows[0].name}
|
|
AND is_listed = true
|
|
AND id = ANY(${nextRemovedPageIds})
|
|
`
|
|
}
|
|
|
|
for (const [index, pageId] of nextPageIds.entries()) {
|
|
await transaction`
|
|
UPDATE pages
|
|
SET listing_sort_order = ${index * 10}, updated_at = now()
|
|
WHERE id = ${pageId}
|
|
AND listing_section = ${sectionRows[0].name}
|
|
AND is_listed = true
|
|
`
|
|
}
|
|
})
|
|
|
|
return listAdminPages()
|
|
}
|
|
|
|
/**
|
|
* 관리자 고정 페이지 생성
|
|
* @param {Object} input - 페이지 입력값
|
|
* @returns {Promise<Object>} 생성된 페이지
|
|
*/
|
|
export const createAdminPage = async (input) => {
|
|
const sql = getPostgresClient()
|
|
|
|
if (!sql) {
|
|
throw new Error('DATABASE_REQUIRED')
|
|
}
|
|
|
|
const rows = await sql`
|
|
INSERT INTO pages (
|
|
title,
|
|
slug,
|
|
content,
|
|
render_mode,
|
|
featured_image,
|
|
is_listed,
|
|
is_featured,
|
|
listing_section,
|
|
listing_title,
|
|
listing_description,
|
|
listing_sort_order,
|
|
status
|
|
)
|
|
VALUES (
|
|
${input.title},
|
|
${input.slug},
|
|
${input.content},
|
|
${input.renderMode},
|
|
${input.featuredImage},
|
|
${input.isListed},
|
|
${input.isFeatured},
|
|
${input.listingSection},
|
|
${input.listingTitle},
|
|
${input.listingDescription},
|
|
${input.listingSortOrder},
|
|
${input.status}
|
|
)
|
|
RETURNING *
|
|
`
|
|
|
|
await createPageCoverThumbnailForImageUrl(input.featuredImage)
|
|
|
|
return mapPageRow(rows[0])
|
|
}
|
|
|
|
/**
|
|
* 관리자 고정 페이지 수정
|
|
* @param {string} id - 페이지 ID
|
|
* @param {Object} input - 페이지 입력값
|
|
* @returns {Promise<Object | null>} 수정된 페이지
|
|
*/
|
|
export const updateAdminPage = async (id, input) => {
|
|
const sql = getPostgresClient()
|
|
|
|
if (!sql) {
|
|
throw new Error('DATABASE_REQUIRED')
|
|
}
|
|
|
|
const rows = await sql`
|
|
UPDATE pages
|
|
SET
|
|
title = ${input.title},
|
|
slug = ${input.slug},
|
|
content = ${input.content},
|
|
render_mode = ${input.renderMode},
|
|
featured_image = ${input.featuredImage},
|
|
is_listed = ${input.isListed},
|
|
is_featured = ${input.isFeatured},
|
|
listing_section = ${input.listingSection},
|
|
listing_title = ${input.listingTitle},
|
|
listing_description = ${input.listingDescription},
|
|
listing_sort_order = ${input.listingSortOrder},
|
|
status = ${input.status},
|
|
updated_at = now()
|
|
WHERE id = ${id}
|
|
RETURNING *
|
|
`
|
|
|
|
if (rows[0]) {
|
|
await createPageCoverThumbnailForImageUrl(input.featuredImage)
|
|
}
|
|
|
|
return rows[0] ? mapPageRow(rows[0]) : null
|
|
}
|
|
|
|
/**
|
|
* 관리자 고정 페이지 삭제
|
|
* @param {string} id - 페이지 ID
|
|
* @returns {Promise<boolean>} 삭제 여부
|
|
*/
|
|
export const deleteAdminPage = async (id) => {
|
|
const sql = getPostgresClient()
|
|
|
|
if (!sql) {
|
|
throw new Error('DATABASE_REQUIRED')
|
|
}
|
|
|
|
const rows = await sql`
|
|
DELETE FROM pages
|
|
WHERE id = ${id}
|
|
RETURNING id
|
|
`
|
|
|
|
return Boolean(rows[0])
|
|
}
|
|
|
|
/**
|
|
* 공개 고정 페이지 상세 조회
|
|
* @param {string} slug - 페이지 슬러그
|
|
* @returns {Promise<Object | null>} 고정 페이지 상세
|
|
*/
|
|
export const getPageBySlug = async (slug) => {
|
|
const sql = getPostgresClient()
|
|
|
|
if (!sql) {
|
|
return getSamplePageBySlug(slug)
|
|
}
|
|
|
|
const rows = await sql`
|
|
SELECT *
|
|
FROM pages
|
|
WHERE slug = ${slug}
|
|
AND status = 'published'
|
|
LIMIT 1
|
|
`
|
|
|
|
return rows[0] ? mapPageRow(rows[0]) : null
|
|
}
|
|
|
|
/**
|
|
* 공개 태그 목록 조회
|
|
* @returns {Promise<Array>} 태그 목록
|
|
*/
|
|
export const listTags = async ({ tagType, searchQuery = '', limit } = {}) => {
|
|
const sql = getPostgresClient()
|
|
const trimmedSearchQuery = String(searchQuery || '').trim().toLowerCase()
|
|
const resolvedLimit = Number.isInteger(limit) && limit > 0 ? limit : null
|
|
|
|
if (!sql) {
|
|
const sampleTags = getSampleTags().map((tag) => ({
|
|
...tag,
|
|
headerImageUrl: tag.headerImageUrl || '',
|
|
headerTitle: tag.headerTitle || '',
|
|
headerText: tag.headerText || '',
|
|
tagType: 'managed',
|
|
postCount: 0,
|
|
lastUsedAt: null,
|
|
updatedAt: null
|
|
}))
|
|
let filteredTags = sampleTags
|
|
if (tagType) {
|
|
filteredTags = filteredTags.filter((tag) => tag.tagType === tagType)
|
|
}
|
|
if (trimmedSearchQuery) {
|
|
filteredTags = filteredTags.filter((tag) =>
|
|
tag.name.toLowerCase().includes(trimmedSearchQuery) ||
|
|
tag.slug.toLowerCase().includes(trimmedSearchQuery)
|
|
)
|
|
}
|
|
return resolvedLimit ? filteredTags.slice(0, resolvedLimit) : filteredTags
|
|
}
|
|
|
|
const rows = await sql`
|
|
SELECT
|
|
tags.*,
|
|
COUNT(posts.id)::int AS post_count,
|
|
MAX(posts.updated_at) AS last_used_at
|
|
FROM tags
|
|
LEFT JOIN post_tags ON post_tags.tag_id = tags.id
|
|
LEFT JOIN posts ON posts.id = post_tags.post_id
|
|
AND posts.status = 'published'
|
|
AND (
|
|
posts.published_at IS NULL
|
|
OR posts.published_at <= now()
|
|
)
|
|
WHERE (${tagType || null}::text IS NULL OR tag_type = ${tagType || null})
|
|
AND (
|
|
${trimmedSearchQuery || null}::text IS NULL
|
|
OR strpos(lower(tags.name), ${trimmedSearchQuery || ''}) > 0
|
|
OR strpos(lower(tags.slug), ${trimmedSearchQuery || ''}) > 0
|
|
)
|
|
GROUP BY tags.id
|
|
ORDER BY
|
|
CASE tag_type WHEN 'managed' THEN 0 ELSE 1 END ASC,
|
|
sort_order ASC,
|
|
MAX(posts.updated_at) DESC NULLS LAST,
|
|
tags.updated_at DESC,
|
|
name ASC
|
|
LIMIT ${resolvedLimit || 1000}
|
|
`
|
|
|
|
return rows.map(mapTagRow)
|
|
}
|
|
|
|
/**
|
|
* 관리자 태그 목록 조회
|
|
* @param {Object} options - 조회 옵션
|
|
* @returns {Promise<Array>} 관리자 태그 목록
|
|
*/
|
|
export const listAdminTags = async (options = {}) => listTags(options)
|
|
|
|
const SEARCH_TAG_LIMIT = 12
|
|
const SEARCH_POST_LIMIT = 12
|
|
const SEARCH_PAGE_LIMIT = 8
|
|
const SEARCH_POST_CANDIDATE_LIMIT = 48
|
|
|
|
/**
|
|
* 공개 검색어를 비교 가능한 문자열로 정리한다.
|
|
* @param {string} value - 원본 검색어
|
|
* @returns {string} 정규화된 검색어
|
|
*/
|
|
const normalizeSearchQuery = (value) => String(value || '')
|
|
.normalize('NFC')
|
|
.replace(/\s+/g, ' ')
|
|
.trim()
|
|
|
|
/**
|
|
* 공개 검색에서 업로드 경로/파일명 같은 노이즈를 제거한다.
|
|
* - 마크다운 이미지 문법 `` 제거
|
|
* - 업로드 경로(`/uploads/...`) 제거
|
|
* @param {string} value - 원문
|
|
* @returns {string} 정규화된 문자열
|
|
*/
|
|
const normalizeSearchContent = (value) => String(value || '')
|
|
.replace(/!\[[^\]]*]\([^)]*\)/g, ' ')
|
|
.replace(/\/uploads\/[^\s)"]+/g, ' ')
|
|
.replace(/\s+/g, ' ')
|
|
.trim()
|
|
|
|
/**
|
|
* 공개 검색: 태그·게시물 제목·요약·본문에서 부분 일치(대소문자 무시)
|
|
* @param {string} rawQuery - 검색어
|
|
* @returns {Promise<{ tags: Array<{ name: string, slug: string }>, posts: Array<{ slug: string, title: string, excerpt: string }>, pages: Array<{ slug: string, title: string, excerpt: string }> }>} 검색 요약 결과
|
|
*/
|
|
export const searchPublicContent = async (rawQuery) => {
|
|
const q = normalizeSearchQuery(rawQuery)
|
|
if (!q) {
|
|
return { tags: [], posts: [], pages: [] }
|
|
}
|
|
|
|
const sql = getPostgresClient()
|
|
|
|
if (!sql) {
|
|
const needle = q.toLowerCase()
|
|
const posts = getSamplePosts()
|
|
.filter((post) => {
|
|
const hay = normalizeSearchContent(`${post.title}\n${post.excerpt || ''}\n${post.content || ''}`).toLowerCase()
|
|
return hay.includes(needle)
|
|
})
|
|
.slice(0, SEARCH_POST_LIMIT)
|
|
.map((post) => ({
|
|
slug: post.slug,
|
|
title: post.title,
|
|
excerpt: post.excerpt || ''
|
|
}))
|
|
const tags = getSampleTags()
|
|
.filter((tag) => {
|
|
const hay = `${tag.name}\n${tag.slug}`.toLowerCase()
|
|
return hay.includes(needle)
|
|
})
|
|
.slice(0, SEARCH_TAG_LIMIT)
|
|
.map((tag) => ({
|
|
name: tag.name,
|
|
slug: tag.slug
|
|
}))
|
|
const pages = getSamplePages()
|
|
.filter((page) => {
|
|
const hay = normalizeSearchContent(`${page.listingSection || ''}\n${page.listingTitle || page.title}\n${page.listingDescription || ''}\n${page.content || ''}`).toLowerCase()
|
|
return page.isListed && hay.includes(needle)
|
|
})
|
|
.slice(0, SEARCH_PAGE_LIMIT)
|
|
.map((page) => ({
|
|
slug: page.slug,
|
|
title: page.listingTitle || page.title,
|
|
excerpt: page.listingDescription || ''
|
|
}))
|
|
|
|
return { tags, posts, pages }
|
|
}
|
|
|
|
const tagRows = await sql`
|
|
SELECT name, slug
|
|
FROM tags
|
|
WHERE
|
|
position(lower(${q}) in lower(name)) > 0
|
|
OR position(lower(${q}) in lower(slug)) > 0
|
|
ORDER BY sort_order ASC, name ASC
|
|
LIMIT ${SEARCH_TAG_LIMIT}
|
|
`
|
|
|
|
const postRows = await sql`
|
|
SELECT posts.slug, posts.title, posts.excerpt, posts.content
|
|
FROM posts
|
|
WHERE posts.status = 'published'
|
|
AND (posts.published_at IS NULL OR posts.published_at <= now())
|
|
AND (
|
|
position(lower(${q}) in lower(posts.title)) > 0
|
|
OR position(lower(${q}) in lower(coalesce(posts.excerpt, ''))) > 0
|
|
OR position(lower(${q}) in lower(posts.content)) > 0
|
|
)
|
|
ORDER BY posts.published_at DESC NULLS LAST, posts.created_at DESC
|
|
LIMIT ${SEARCH_POST_CANDIDATE_LIMIT}
|
|
`
|
|
|
|
const pageRows = await sql`
|
|
SELECT slug, title, content, listing_section, listing_title, listing_description
|
|
FROM pages
|
|
WHERE status = 'published'
|
|
AND is_listed = true
|
|
AND (
|
|
position(lower(${q}) in lower(title)) > 0
|
|
OR position(lower(${q}) in lower(coalesce(listing_section, ''))) > 0
|
|
OR position(lower(${q}) in lower(coalesce(listing_title, ''))) > 0
|
|
OR position(lower(${q}) in lower(coalesce(listing_description, ''))) > 0
|
|
OR position(lower(${q}) in lower(content)) > 0
|
|
)
|
|
ORDER BY is_featured DESC, listing_section ASC, listing_sort_order ASC, updated_at DESC
|
|
LIMIT ${SEARCH_PAGE_LIMIT}
|
|
`
|
|
|
|
const needle = q.toLowerCase()
|
|
const posts = postRows
|
|
.filter((row) => {
|
|
const hay = normalizeSearchContent(`${row.title}\n${row.excerpt || ''}\n${row.content || ''}`).toLowerCase()
|
|
return hay.includes(needle)
|
|
})
|
|
.slice(0, SEARCH_POST_LIMIT)
|
|
|
|
return {
|
|
tags: tagRows.map((row) => ({ name: row.name, slug: row.slug })),
|
|
posts: posts.map((row) => ({
|
|
slug: row.slug,
|
|
title: row.title,
|
|
excerpt: row.excerpt || ''
|
|
})),
|
|
pages: pageRows.map((row) => ({
|
|
slug: row.slug,
|
|
title: row.listing_title || row.title,
|
|
excerpt: row.listing_description || ''
|
|
}))
|
|
}
|
|
}
|
|
|
|
/**
|
|
* 사이트 설정 조회
|
|
* @returns {Promise<Object>} 사이트 설정
|
|
*/
|
|
export const getSiteSettings = async () => {
|
|
const sql = getPostgresClient()
|
|
|
|
if (!sql) {
|
|
return getDefaultSiteSettings()
|
|
}
|
|
|
|
const rows = await sql`
|
|
SELECT *
|
|
FROM site_settings
|
|
WHERE id = 1
|
|
LIMIT 1
|
|
`
|
|
|
|
return rows[0] ? mapSiteSettingsRow(rows[0]) : getDefaultSiteSettings()
|
|
}
|
|
|
|
/**
|
|
* 관리자 사이트 설정 수정
|
|
* @param {Object} input - 사이트 설정 입력값
|
|
* @returns {Promise<Object>} 수정된 사이트 설정
|
|
*/
|
|
export const updateSiteSettings = async (input) => {
|
|
const sql = getPostgresClient()
|
|
|
|
if (!sql) {
|
|
throw new Error('DATABASE_REQUIRED')
|
|
}
|
|
|
|
const rows = await sql`
|
|
INSERT INTO site_settings (
|
|
id,
|
|
title,
|
|
description,
|
|
site_url,
|
|
logo_text,
|
|
logo_url,
|
|
favicon_url,
|
|
copyright_text,
|
|
social_links,
|
|
show_post_updated_at,
|
|
post_tag_limit,
|
|
home_latest_post_limit,
|
|
post_list_page_size,
|
|
tag_post_list_page_size,
|
|
featured_post_limit,
|
|
page_section_item_limit,
|
|
upload_max_file_count,
|
|
upload_max_total_size,
|
|
home_cover_image_url,
|
|
home_cover_dark_image_url,
|
|
home_cover_title,
|
|
home_cover_text,
|
|
brand_color,
|
|
announcement_enabled,
|
|
announcement_text,
|
|
announcement_url,
|
|
announcement_background_color,
|
|
announcement_alignment,
|
|
signup_blocked_usernames,
|
|
ads_txt,
|
|
custom_head_code,
|
|
custom_footer_code,
|
|
ad_home_feed_code,
|
|
ad_home_infeed_code,
|
|
ad_sidebar_code,
|
|
ad_post_sidebar_code,
|
|
ad_post_top_code,
|
|
ad_post_in_article_code,
|
|
ad_post_bottom_code,
|
|
updated_at
|
|
)
|
|
VALUES (
|
|
1,
|
|
${input.title},
|
|
${input.description},
|
|
${input.siteUrl},
|
|
${input.logoText || '井'},
|
|
${input.logoUrl || ''},
|
|
${input.faviconUrl || ''},
|
|
${input.copyrightText},
|
|
${JSON.stringify(normalizeSocialLinks(input.socialLinks))}::jsonb,
|
|
${input.showPostUpdatedAt ? true : false},
|
|
${normalizePostTagLimit(input.postTagLimit)},
|
|
${normalizeDisplayCount(input.homeLatestPostLimit, DEFAULT_HOME_LATEST_POST_LIMIT)},
|
|
${normalizeDisplayCount(input.postListPageSize, DEFAULT_POST_LIST_PAGE_SIZE)},
|
|
${normalizeDisplayCount(input.tagPostListPageSize, DEFAULT_TAG_POST_LIST_PAGE_SIZE)},
|
|
${normalizeDisplayCount(input.featuredPostLimit, DEFAULT_FEATURED_POST_LIMIT)},
|
|
${normalizeDisplayCount(input.pageSectionItemLimit, DEFAULT_PAGE_SECTION_ITEM_LIMIT)},
|
|
${normalizeUploadMaxFileCount(input.uploadMaxFileCount)},
|
|
${normalizeUploadMaxTotalSize(input.uploadMaxTotalSize)},
|
|
${input.homeCoverImageUrl || ''},
|
|
${input.homeCoverDarkImageUrl || ''},
|
|
${input.homeCoverTitle || ''},
|
|
${input.homeCoverText || ''},
|
|
${normalizeBrandColor(input.brandColor)},
|
|
${input.announcementEnabled ? true : false},
|
|
${input.announcementText || ''},
|
|
${input.announcementUrl || ''},
|
|
${normalizeAnnouncementBackgroundColor(input.announcementBackgroundColor)},
|
|
${normalizeAnnouncementAlignment(input.announcementAlignment)},
|
|
${JSON.stringify(normalizeSignupBlockedUsernames(input.signupBlockedUsernames))},
|
|
${input.adsTxt || ''},
|
|
${input.customHeadCode || ''},
|
|
${input.customFooterCode || ''},
|
|
${input.adHomeFeedCode || ''},
|
|
${input.adHomeInfeedCode || ''},
|
|
${input.adSidebarCode || ''},
|
|
${input.adPostSidebarCode || ''},
|
|
${input.adPostTopCode || ''},
|
|
${input.adPostInArticleCode || ''},
|
|
${input.adPostBottomCode || ''},
|
|
now()
|
|
)
|
|
ON CONFLICT (id) DO UPDATE
|
|
SET
|
|
title = EXCLUDED.title,
|
|
description = EXCLUDED.description,
|
|
site_url = EXCLUDED.site_url,
|
|
logo_text = EXCLUDED.logo_text,
|
|
logo_url = EXCLUDED.logo_url,
|
|
favicon_url = EXCLUDED.favicon_url,
|
|
copyright_text = EXCLUDED.copyright_text,
|
|
social_links = EXCLUDED.social_links,
|
|
show_post_updated_at = EXCLUDED.show_post_updated_at,
|
|
post_tag_limit = EXCLUDED.post_tag_limit,
|
|
home_latest_post_limit = EXCLUDED.home_latest_post_limit,
|
|
post_list_page_size = EXCLUDED.post_list_page_size,
|
|
tag_post_list_page_size = EXCLUDED.tag_post_list_page_size,
|
|
featured_post_limit = EXCLUDED.featured_post_limit,
|
|
page_section_item_limit = EXCLUDED.page_section_item_limit,
|
|
upload_max_file_count = EXCLUDED.upload_max_file_count,
|
|
upload_max_total_size = EXCLUDED.upload_max_total_size,
|
|
home_cover_image_url = EXCLUDED.home_cover_image_url,
|
|
home_cover_dark_image_url = EXCLUDED.home_cover_dark_image_url,
|
|
home_cover_title = EXCLUDED.home_cover_title,
|
|
home_cover_text = EXCLUDED.home_cover_text,
|
|
brand_color = EXCLUDED.brand_color,
|
|
announcement_enabled = EXCLUDED.announcement_enabled,
|
|
announcement_text = EXCLUDED.announcement_text,
|
|
announcement_url = EXCLUDED.announcement_url,
|
|
announcement_background_color = EXCLUDED.announcement_background_color,
|
|
announcement_alignment = EXCLUDED.announcement_alignment,
|
|
signup_blocked_usernames = EXCLUDED.signup_blocked_usernames,
|
|
ads_txt = EXCLUDED.ads_txt,
|
|
custom_head_code = EXCLUDED.custom_head_code,
|
|
custom_footer_code = EXCLUDED.custom_footer_code,
|
|
ad_home_feed_code = EXCLUDED.ad_home_feed_code,
|
|
ad_home_infeed_code = EXCLUDED.ad_home_infeed_code,
|
|
ad_sidebar_code = EXCLUDED.ad_sidebar_code,
|
|
ad_post_sidebar_code = EXCLUDED.ad_post_sidebar_code,
|
|
ad_post_top_code = EXCLUDED.ad_post_top_code,
|
|
ad_post_in_article_code = EXCLUDED.ad_post_in_article_code,
|
|
ad_post_bottom_code = EXCLUDED.ad_post_bottom_code,
|
|
updated_at = now()
|
|
RETURNING *
|
|
`
|
|
|
|
return mapSiteSettingsRow(rows[0])
|
|
}
|
|
|
|
/**
|
|
* 사이트 로고 URL을 수정한다.
|
|
* @param {{ logoUrl: string, faviconUrl: string }} input - 로고 URL
|
|
* @returns {Promise<Object>} 수정된 사이트 설정
|
|
*/
|
|
export const updateSiteLogo = async (input) => {
|
|
const sql = getPostgresClient()
|
|
|
|
if (!sql) {
|
|
throw new Error('DATABASE_REQUIRED')
|
|
}
|
|
|
|
const rows = await sql`
|
|
INSERT INTO site_settings (
|
|
id,
|
|
logo_url,
|
|
favicon_url,
|
|
updated_at
|
|
)
|
|
VALUES (
|
|
1,
|
|
${input.logoUrl},
|
|
${input.faviconUrl},
|
|
now()
|
|
)
|
|
ON CONFLICT (id) DO UPDATE
|
|
SET
|
|
logo_url = EXCLUDED.logo_url,
|
|
favicon_url = EXCLUDED.favicon_url,
|
|
updated_at = now()
|
|
RETURNING *
|
|
`
|
|
|
|
return mapSiteSettingsRow(rows[0])
|
|
}
|
|
|
|
/**
|
|
* 메인 화면 커버 이미지 URL을 수정한다.
|
|
* @param {{ homeCoverImageUrl: string }} input - 커버 이미지 URL
|
|
* @returns {Promise<Object>} 수정된 사이트 설정
|
|
*/
|
|
export const updateSiteHomeCoverImage = async (input) => {
|
|
const sql = getPostgresClient()
|
|
|
|
if (!sql) {
|
|
throw new Error('DATABASE_REQUIRED')
|
|
}
|
|
|
|
const rows = await sql`
|
|
INSERT INTO site_settings (
|
|
id,
|
|
home_cover_image_url,
|
|
updated_at
|
|
)
|
|
VALUES (
|
|
1,
|
|
${input.homeCoverImageUrl || ''},
|
|
now()
|
|
)
|
|
ON CONFLICT (id) DO UPDATE
|
|
SET
|
|
home_cover_image_url = EXCLUDED.home_cover_image_url,
|
|
updated_at = now()
|
|
RETURNING *
|
|
`
|
|
|
|
return mapSiteSettingsRow(rows[0])
|
|
}
|
|
|
|
/**
|
|
* 네비게이션 항목 목록 조회
|
|
* @param {Object} options - 조회 옵션
|
|
* @param {boolean} options.visibleOnly - 표시 항목만 조회할지 여부
|
|
* @returns {Promise<Array>} 네비게이션 항목 목록
|
|
*/
|
|
export const listNavigationItems = async ({ visibleOnly = false } = {}) => {
|
|
const sql = getPostgresClient()
|
|
|
|
if (!sql) {
|
|
return getDefaultNavigationItems()
|
|
.filter((item) => !visibleOnly || item.isVisible)
|
|
}
|
|
|
|
const rows = visibleOnly
|
|
? await sql`
|
|
SELECT *
|
|
FROM navigation_items
|
|
WHERE is_visible = true
|
|
ORDER BY location ASC, sort_order ASC, label ASC
|
|
`
|
|
: await sql`
|
|
SELECT *
|
|
FROM navigation_items
|
|
ORDER BY location ASC, sort_order ASC, label ASC
|
|
`
|
|
|
|
return rows.map(mapNavigationItemRow)
|
|
}
|
|
|
|
/**
|
|
* 공개 네비게이션 조회
|
|
* @returns {Promise<{primary: Array<Object>, footer: Array<Object>, recommended: Array<Object>}>} 위치별 공개 네비게이션
|
|
*/
|
|
export const getPublicNavigation = async () => {
|
|
const flat = await listNavigationItems({ visibleOnly: true })
|
|
const primaryFlat = flat.filter((item) => item.location === 'primary')
|
|
const footerFlat = flat
|
|
.filter((item) => item.location === 'footer' && !item.parentId)
|
|
.sort((a, b) => (a.sortOrder || 0) - (b.sortOrder || 0))
|
|
const recommendedFlat = flat
|
|
.filter((item) => item.location === 'recommended' && !item.parentId)
|
|
.sort((a, b) => (a.sortOrder || 0) - (b.sortOrder || 0))
|
|
|
|
return {
|
|
primary: buildPublicPrimaryTree(primaryFlat),
|
|
footer: footerFlat.map((item) => ({
|
|
id: item.id,
|
|
label: item.label,
|
|
url: item.url,
|
|
isVisible: item.isVisible
|
|
})),
|
|
recommended: recommendedFlat.map((item) => ({
|
|
id: item.id,
|
|
label: item.label,
|
|
url: item.url,
|
|
descriptionText: item.descriptionText,
|
|
thumbnailUrl: item.thumbnailUrl,
|
|
cachedFaviconUrl: item.cachedFaviconUrl,
|
|
isVisible: item.isVisible
|
|
}))
|
|
}
|
|
}
|
|
|
|
/**
|
|
* 관리자 네비게이션 항목 일괄 저장
|
|
* @param {Array<Object>} items - 저장할 네비게이션 항목 목록
|
|
* @returns {Promise<Array>} 저장된 네비게이션 항목 목록
|
|
*/
|
|
export const updateNavigationItems = async (items) => {
|
|
const sql = getPostgresClient()
|
|
|
|
if (!sql) {
|
|
throw new Error('DATABASE_REQUIRED')
|
|
}
|
|
|
|
const existingRows = await sql`
|
|
SELECT id, cached_favicon_url, favicon_cached_at
|
|
FROM navigation_items
|
|
`
|
|
const faviconCacheById = new Map(
|
|
existingRows.map((row) => [
|
|
String(row.id),
|
|
{
|
|
cachedFaviconUrl: row.cached_favicon_url || '',
|
|
faviconCachedAt: row.favicon_cached_at ?? null
|
|
}
|
|
])
|
|
)
|
|
|
|
await sql.begin(async (transaction) => {
|
|
await transaction`
|
|
DELETE FROM navigation_items
|
|
`
|
|
|
|
const ordered = orderNavigationItemsForInsert(items)
|
|
for (const item of ordered) {
|
|
const cached = faviconCacheById.get(String(item.id)) || {
|
|
cachedFaviconUrl: '',
|
|
faviconCachedAt: null
|
|
}
|
|
|
|
await transaction`
|
|
INSERT INTO navigation_items (
|
|
id,
|
|
label,
|
|
url,
|
|
description_text,
|
|
thumbnail_url,
|
|
cached_favicon_url,
|
|
favicon_cached_at,
|
|
location,
|
|
sort_order,
|
|
is_visible,
|
|
parent_id,
|
|
is_folder
|
|
)
|
|
VALUES (
|
|
${item.id},
|
|
${item.label},
|
|
${item.url},
|
|
${item.descriptionText || ''},
|
|
${item.thumbnailUrl || ''},
|
|
${cached.cachedFaviconUrl},
|
|
${cached.faviconCachedAt},
|
|
${item.location},
|
|
${item.sortOrder},
|
|
${item.isVisible},
|
|
${item.parentId ?? null},
|
|
${Boolean(item.isFolder)}
|
|
)
|
|
`
|
|
}
|
|
})
|
|
|
|
return listNavigationItems()
|
|
}
|
|
|
|
/**
|
|
* 네비게이션 항목 단건 조회
|
|
* @param {string} id - 항목 ID
|
|
* @returns {Promise<Object | null>} 네비게이션 항목
|
|
*/
|
|
export const getNavigationItemById = async (id) => {
|
|
const sql = getPostgresClient()
|
|
|
|
if (!sql) {
|
|
return null
|
|
}
|
|
|
|
const rows = await sql`
|
|
SELECT *
|
|
FROM navigation_items
|
|
WHERE id = ${id}
|
|
LIMIT 1
|
|
`
|
|
|
|
return rows[0] ? mapNavigationItemRow(rows[0]) : null
|
|
}
|
|
|
|
/**
|
|
* 추천 사이트 파비콘 캐시를 갱신한다.
|
|
* @param {string} id - 항목 ID
|
|
* @param {string} cachedFaviconUrl - 저장된 파비콘 URL
|
|
* @returns {Promise<Object | null>} 갱신된 항목
|
|
*/
|
|
export const updateNavigationItemFaviconCache = async (id, cachedFaviconUrl) => {
|
|
const sql = getPostgresClient()
|
|
|
|
if (!sql) {
|
|
throw new Error('DATABASE_REQUIRED')
|
|
}
|
|
|
|
const rows = await sql`
|
|
UPDATE navigation_items
|
|
SET
|
|
cached_favicon_url = ${cachedFaviconUrl},
|
|
favicon_cached_at = NOW(),
|
|
updated_at = NOW()
|
|
WHERE id = ${id}
|
|
RETURNING *
|
|
`
|
|
|
|
return rows[0] ? mapNavigationItemRow(rows[0]) : null
|
|
}
|
|
|
|
/**
|
|
* 관리자 태그 상세 조회
|
|
* @param {string} id - 태그 ID
|
|
* @returns {Promise<Object | null>} 태그 상세
|
|
*/
|
|
export const getAdminTagById = async (id) => {
|
|
const sql = getPostgresClient()
|
|
|
|
if (!sql) {
|
|
return getSampleTags().find((tag) => tag.id === id) || null
|
|
}
|
|
|
|
const rows = await sql`
|
|
SELECT *
|
|
FROM tags
|
|
WHERE id = ${id}
|
|
LIMIT 1
|
|
`
|
|
|
|
return rows[0] ? mapTagRow(rows[0]) : null
|
|
}
|
|
|
|
/**
|
|
* 관리자 태그 생성
|
|
* @param {Object} input - 태그 입력값
|
|
* @returns {Promise<Object>} 생성된 태그
|
|
*/
|
|
export const createAdminTag = async (input) => {
|
|
const sql = getPostgresClient()
|
|
|
|
if (!sql) {
|
|
throw new Error('DATABASE_REQUIRED')
|
|
}
|
|
|
|
const rows = await sql`
|
|
INSERT INTO tags (name, slug, description, header_image_url, header_title, header_text, sort_order, color, tag_type)
|
|
VALUES (${input.name}, ${input.slug}, ${input.description}, ${input.headerImageUrl}, ${input.headerTitle}, ${input.headerText}, ${input.sortOrder}, ${input.color}, ${input.tagType})
|
|
RETURNING *
|
|
`
|
|
|
|
return mapTagRow(rows[0])
|
|
}
|
|
|
|
/**
|
|
* 관리자 태그 수정
|
|
* @param {string} id - 태그 ID
|
|
* @param {Object} input - 태그 입력값
|
|
* @returns {Promise<Object | null>} 수정된 태그
|
|
*/
|
|
export const updateAdminTag = async (id, input) => {
|
|
const sql = getPostgresClient()
|
|
|
|
if (!sql) {
|
|
throw new Error('DATABASE_REQUIRED')
|
|
}
|
|
|
|
const rows = await sql`
|
|
UPDATE tags
|
|
SET
|
|
name = ${input.name},
|
|
slug = ${input.slug},
|
|
description = ${input.description},
|
|
header_image_url = ${input.headerImageUrl},
|
|
header_title = ${input.headerTitle},
|
|
header_text = ${input.headerText},
|
|
sort_order = ${input.sortOrder},
|
|
color = ${input.color},
|
|
tag_type = ${input.tagType},
|
|
updated_at = now()
|
|
WHERE id = ${id}
|
|
RETURNING *
|
|
`
|
|
|
|
return rows[0] ? mapTagRow(rows[0]) : null
|
|
}
|
|
|
|
/**
|
|
* 관리자 관리용 태그 순서를 일괄 갱신
|
|
* @param {Array<string>} tagIds - 정렬된 태그 ID 목록
|
|
* @returns {Promise<Array>} 갱신된 태그 목록
|
|
*/
|
|
export const reorderManagedTags = async (tagIds) => {
|
|
const sql = getPostgresClient()
|
|
|
|
if (!sql) {
|
|
throw new Error('DATABASE_REQUIRED')
|
|
}
|
|
|
|
await sql.begin(async (transaction) => {
|
|
for (let index = 0; index < tagIds.length; index += 1) {
|
|
const tagId = tagIds[index]
|
|
await transaction`
|
|
UPDATE tags
|
|
SET
|
|
sort_order = ${(index + 1) * 10},
|
|
updated_at = now()
|
|
WHERE id = ${tagId}
|
|
AND tag_type = 'managed'
|
|
`
|
|
}
|
|
})
|
|
|
|
return listTags({ tagType: 'managed' })
|
|
}
|
|
|
|
/**
|
|
* 관리자 태그 삭제
|
|
* @param {string} id - 태그 ID
|
|
* @returns {Promise<boolean>} 삭제 여부
|
|
*/
|
|
export const deleteAdminTag = async (id) => {
|
|
const sql = getPostgresClient()
|
|
|
|
if (!sql) {
|
|
throw new Error('DATABASE_REQUIRED')
|
|
}
|
|
|
|
const rows = await sql`
|
|
DELETE FROM tags
|
|
WHERE id = ${id}
|
|
RETURNING id
|
|
`
|
|
|
|
return Boolean(rows[0])
|
|
}
|