Files
moeum-server/src/modules/global/database/schema.ts
T
dahyeon f77f5f9543 Adds article retrieval and taxonomy path APIs
Implements endpoints to fetch article details and associated taxonomy paths by slug, enhancing content discovery and structure.

Introduces response DTOs and updates data models to support richer metadata and timestamp fields for improved API consistency.
2025-11-13 16:30:19 +00:00

194 lines
5.3 KiB
TypeScript

import mongoose, { Schema, Document } from 'mongoose';
import { ModelDefinition } from './types';
export interface MongooseTimestamps {
createdAt: Date;
updatedAt: Date;
}
export interface Metadata {
key: string;
value: string | any[] | null;
dataType: string;
isReserved: boolean;
}
export interface TaxonomyChildItem {
title: string;
order: number;
articleId?: mongoose.Types.ObjectId;
slug?: string; //article document의 slug 참조 (임베딩)
children?: TaxonomyChildItem[];
}
export interface Taxonomy
extends Document<mongoose.Types.ObjectId>,
MongooseTimestamps {
label: string;
items: TaxonomyChildItem[];
metadatas: Metadata[];
}
export interface ContentSection {
heading: string;
taxonomies: mongoose.Types.ObjectId[];
}
export interface Content
extends Document<mongoose.Types.ObjectId>,
MongooseTimestamps {
key: string;
label: string;
sections: ContentSection[];
}
export interface Article
extends Document<mongoose.Types.ObjectId>,
MongooseTimestamps {
title: string;
slug: string;
content: string;
status: 'draft' | 'published' | 'archived';
metadatas: Metadata[];
}
export const MetadataSubSchema = new mongoose.Schema<Metadata>({
key: { type: String, required: true },
value: {
type: mongoose.SchemaTypes.Mixed,
required: false, // required: true로 하면 value가 null인 경우 에러 발생
default: null,
validate: {
validator: function (v: string | any[] | null) {
// 특정 키인 경우 value가 null 또는 빈 문자열이 아니어야 함
// if (this.key === 'requiredKey') {
// return typeof v === 'string' && v.trim().length > 0;
// }
// 그렇지 않은 경우 value는 null 또는 문자열, Array이어야 함
return v === null || typeof v === 'string' || Array.isArray(v);
},
message: function (props: any) {
if (this.key === 'requiredKey') {
return `Value is required for key "${this.key}" and cannot be null or empty.`;
}
return `Value must be a string, an array, or null for key "${this.key}".`;
},
},
},
dataType: { type: String, required: false, default: 'string' },
isReserved: { type: Boolean, required: false, default: false },
});
export const TaxonomyChildItemSchema = new Schema(
{
title: { type: String, required: true },
order: { type: Number, required: true, default: 100 },
slug: { type: String }, // slug는 없을 수도 있으므로 required 제외
articleId: { type: Schema.Types.ObjectId, ref: 'article' },
},
{
_id: false, // 하위 아이템마다 _id가 생성되는 것을 방지 (선택 사항)
},
);
// **중요: 재귀 참조 설정**
// 스키마 정의 후 .add()를 통해 자기 자신을 children 배열로 추가합니다.
TaxonomyChildItemSchema.add({
children: { type: [TaxonomyChildItemSchema], default: [] },
});
// 2. 메인 도큐먼트 스키마 (Root)
export const TaxonomySchema = new Schema(
{
// items 배열은 위에서 정의한 재귀 스키마를 따름
label: { type: String, required: true },
items: {
type: [TaxonomyChildItemSchema],
default: [],
},
// metadata는 구조가 가변적이므로 Mixed 타입 사용
metadatas: {
type: [MetadataSubSchema],
required: true,
default: [],
validate: {
validator: function (metas: Metadata[]) {
const keys = metas.map((m) => m.key);
return keys.length === new Set(keys).size;
},
message: 'Duplicate metadata keys are not allowed.',
},
},
},
{
timestamps: true, // createAt, updatedAt 자동 생성
collection: 'taxonomy', // 컬렉션 이름 지정
},
);
TaxonomySchema.index({ label: 1 }, { unique: true });
export const ContentSchema = new Schema(
{
key: { type: String, required: true, unique: true },
label: { type: String, required: true },
sections: {
type: [
{
heading: { type: String, required: true },
taxonomies: [{ type: Schema.Types.ObjectId, ref: 'taxonomy' }],
},
],
default: [],
},
},
{
timestamps: true,
collection: 'content',
},
);
export const ArticleSchema = new Schema(
{
title: { type: String, required: true },
content: { type: String, required: true },
slug: { type: String, required: true, unique: true },
status: {
type: String,
enum: ['draft', 'published', 'archived'],
default: 'draft',
},
metadatas: {
type: [MetadataSubSchema],
required: true,
default: [],
validate: {
validator: function (metas: Metadata[]) {
const keys = metas.map((m) => m.key);
return keys.length === new Set(keys).size;
},
message: 'Duplicate metadata keys are not allowed.',
},
},
},
{
timestamps: true,
collection: 'article',
},
);
ArticleSchema.index({ title: 'text', content: 'text' });
export const moeumModelDefinitions: ModelDefinition[] = [
{ name: 'taxonomy', schema: TaxonomySchema, schemaName: 'taxonomy' },
{ name: 'content', schema: ContentSchema, schemaName: 'content' },
{ name: 'article', schema: ArticleSchema, schemaName: 'article' },
];
export interface MoeumModelTypes {
taxonomy: Taxonomy;
content: Content;
article: Article;
}