Blog Platform

blog-platform/
├── src/
│   ├── models/
│   │   ├── User.ts
│   │   ├── Post.ts
│   │   ├── Category.ts
│   │   ├── Tag.ts
│   │   ├── Comment.ts
│   │   └── Media.ts
│   ├── services/
│   │   ├── PostService.ts
│   │   ├── UserService.ts
│   │   ├── CommentService.ts
│   │   └── SearchService.ts
│   ├── controllers/
│   │   ├── PostController.ts
│   │   ├── UserController.ts
│   │   └── CommentController.ts
│   ├── middleware/
│   │   ├── auth.ts
│   │   ├── validation.ts
│   │   └── seo.ts
│   ├── config/
│   │   └── query-2jz.config.ts
│   └── index.ts
├── package.json
├── tsconfig.json
└── README.md

// src/models/Post.ts
export interface Post {
  id: string;
  title: string;
  slug: string;
  excerpt: string;
  content: string;
  featuredImage?: string;
  status: 'draft' | 'published' | 'archived';
  visibility: 'public' | 'private' | 'password';
  password?: string;
  authorId: string;
  categoryId?: string;
  tags: string[];
  seo: {
    title?: string;
    description?: string;
    keywords?: string[];
    canonicalUrl?: string;
    ogImage?: string;
  };
  readingTime: number;
  wordCount: number;
  viewCount: number;
  likeCount: number;
  commentCount: number;
  publishedAt?: Date;
  scheduledAt?: Date;
  createdAt: Date;
  updatedAt: Date;
  author?: User;
  category?: Category;
  comments?: Comment[];
  media?: Media[];
}

export interface Category {
  id: string;
  name: string;
  slug: string;
  description?: string;
  color?: string;
  icon?: string;
  parentId?: string;
  isActive: boolean;
  postCount: number;
  createdAt: Date;
  updatedAt: Date;
  parent?: Category;
  children?: Category[];
  posts?: Post[];
}

export interface Tag {
  id: string;
  name: string;
  slug: string;
  description?: string;
  color?: string;
  postCount: number;
  createdAt: Date;
  updatedAt: Date;
  posts?: Post[];
}

export interface Comment {
  id: string;
  postId: string;
  authorId?: string;
  authorName: string;
  authorEmail: string;
  authorUrl?: string;
  content: string;
  status: 'pending' | 'approved' | 'spam' | 'trash';
  parentId?: string;
  ipAddress: string;
  userAgent?: string;
  isAuthor: boolean;
  createdAt: Date;
  updatedAt: Date;
  post?: Post;
  author?: User;
  parent?: Comment;
  replies?: Comment[];
}

export interface Media {
  id: string;
  filename: string;
  originalName: string;
  mimeType: string;
  size: number;
  url: string;
  thumbnailUrl?: string;
  alt?: string;
  caption?: string;
  uploadedBy: string;
  postId?: string;
  createdAt: Date;
  updatedAt: Date;
  uploader?: User;
  post?: Post;
}

// src/models/User.ts
export interface User {
  id: string;
  username: string;
  email: string;
  displayName: string;
  firstName?: string;
  lastName?: string;
  avatar?: string;
  bio?: string;
  website?: string;
  location?: string;
  role: 'admin' | 'editor' | 'author' | 'contributor' | 'subscriber';
  status: 'active' | 'inactive' | 'suspended';
  emailVerified: boolean;
  lastLoginAt?: Date;
  preferences: {
    theme: 'light' | 'dark';
    language: string;
    timezone: string;
    notifications: {
      email: boolean;
      push: boolean;
      comments: boolean;
      posts: boolean;
    };
  };
  social: {
    twitter?: string;
    facebook?: string;
    instagram?: string;
    linkedin?: string;
    github?: string;
  };
  stats: {
    postCount: number;
    commentCount: number;
    viewCount: number;
    likeCount: number;
  };
  createdAt: Date;
  updatedAt: Date;
  posts?: Post[];
  comments?: Comment[];
  media?: Media[];
}

// src/services/PostService.ts
import { Query-2jz } from 'query-2jz';
import { Post } from '../models/Post';

export class PostService {
  constructor(private query-2jz: Query-2jz) {}

  async createPost(data: {
    title: string;
    content: string;
    excerpt?: string;
    authorId: string;
    categoryId?: string;
    tags?: string[];
    status?: string;
    visibility?: string;
    seo?: any;
  }) {
    const slug = this.generateSlug(data.title);
    
    // Calculate reading time and word count
    const wordCount = this.countWords(data.content);
    const readingTime = Math.ceil(wordCount / 200); // 200 words per minute

    const post = await this.query-2jz.create({
      model: 'Post',
      data: {
        title: data.title,
        slug,
        content: data.content,
        excerpt: data.excerpt || this.generateExcerpt(data.content),
        authorId: data.authorId,
        categoryId: data.categoryId,
        tags: data.tags || [],
        status: data.status || 'draft',
        visibility: data.visibility || 'public',
        seo: data.seo || {},
        readingTime,
        wordCount
      }
    });

    // Update category post count
    if (data.categoryId) {
      await this.updateCategoryPostCount(data.categoryId);
    }

    return post;
  }

  async updatePost(id: string, data: Partial<Post>) {
    const existingPost = await this.query-2jz.query({
      model: 'Post',
      where: { id }
    });

    if (existingPost.data.length === 0) {
      throw new Error('Post not found');
    }

    const updateData: any = { ...data };

    // Regenerate slug if title changed
    if (data.title && data.title !== existingPost.data[0].title) {
      updateData.slug = this.generateSlug(data.title);
    }

    // Recalculate reading time and word count if content changed
    if (data.content) {
      updateData.wordCount = this.countWords(data.content);
      updateData.readingTime = Math.ceil(updateData.wordCount / 200);
    }

    const updatedPost = await this.query-2jz.update({
      model: 'Post',
      id,
      data: updateData
    });

    return updatedPost;
  }

  async publishPost(id: string) {
    const post = await this.query-2jz.query({
      model: 'Post',
      where: { id }
    });

    if (post.data.length === 0) {
      throw new Error('Post not found');
    }

    return this.query-2jz.update({
      model: 'Post',
      id,
      data: {
        status: 'published',
        publishedAt: new Date()
      }
    });
  }

  async getPosts(filters: {
    status?: string;
    authorId?: string;
    categoryId?: string;
    tags?: string[];
    search?: string;
    limit?: number;
    offset?: number;
  }) {
    const where: any = {};

    if (filters.status) {
      where.status = filters.status;
    }

    if (filters.authorId) {
      where.authorId = filters.authorId;
    }

    if (filters.categoryId) {
      where.categoryId = filters.categoryId;
    }

    if (filters.tags && filters.tags.length > 0) {
      where.tags = { $overlap: filters.tags };
    }

    if (filters.search) {
      where.$or = [
        { title: { $like: `%${filters.search}%` } },
        { content: { $like: `%${filters.search}%` } },
        { excerpt: { $like: `%${filters.search}%` } }
      ];
    }

    return this.query-2jz.query({
      model: 'Post',
      where,
      include: ['author', 'category', 'comments'],
      orderBy: 'publishedAt:desc',
      limit: filters.limit || 10,
      offset: filters.offset || 0
    });
  }

  async getPost(slug: string) {
    const post = await this.query-2jz.query({
      model: 'Post',
      where: { slug },
      include: ['author', 'category', 'comments', 'comments.author']
    });

    if (post.data.length === 0) {
      throw new Error('Post not found');
    }

    // Increment view count
    await this.incrementViewCount(post.data[0].id);

    return post.data[0];
  }

  async getRelatedPosts(postId: string, limit = 5) {
    const post = await this.query-2jz.query({
      model: 'Post',
      where: { id: postId }
    });

    if (post.data.length === 0) {
      return [];
    }

    const postData = post.data[0];
    const where: any = {
      id: { $ne: postId },
      status: 'published'
    };

    // Find posts with same category or tags
    if (postData.categoryId) {
      where.categoryId = postData.categoryId;
    }

    if (postData.tags && postData.tags.length > 0) {
      where.tags = { $overlap: postData.tags };
    }

    const relatedPosts = await this.query-2jz.query({
      model: 'Post',
      where,
      include: ['author', 'category'],
      orderBy: 'publishedAt:desc',
      limit
    });

    return relatedPosts.data;
  }

  async incrementViewCount(postId: string) {
    const post = await this.query-2jz.query({
      model: 'Post',
      where: { id: postId }
    });

    if (post.data.length > 0) {
      await this.query-2jz.update({
        model: 'Post',
        id: postId,
        data: {
          viewCount: post.data[0].viewCount + 1
        }
      });
    }
  }

  async updateCategoryPostCount(categoryId: string) {
    const posts = await this.query-2jz.query({
      model: 'Post',
      where: { categoryId, status: 'published' }
    });

    await this.query-2jz.update({
      model: 'Category',
      id: categoryId,
      data: {
        postCount: posts.meta.total
      }
    });
  }

  private generateSlug(title: string): string {
    return title
      .toLowerCase()
      .replace(/[^a-z0-9 -]/g, '')
      .replace(/s+/g, '-')
      .replace(/-+/g, '-')
      .trim('-');
  }

  private generateExcerpt(content: string, length = 160): string {
    const plainText = content.replace(/<[^>]*>/g, '');
    return plainText.length > length 
      ? plainText.substring(0, length) + '...'
      : plainText;
  }

  private countWords(text: string): number {
    const plainText = text.replace(/<[^>]*>/g, '');
    return plainText.split(/s+/).filter(word => word.length > 0).length;
  }
}

// src/controllers/PostController.ts
import { Request, Response } from 'express';
import { PostService } from '../services/PostService';

export class PostController {
  constructor(private postService: PostService) {}

  async getPosts(req: Request, res: Response) {
    try {
      const {
        status = 'published',
        authorId,
        categoryId,
        tags,
        search,
        limit = 10,
        offset = 0
      } = req.query;

      const posts = await this.postService.getPosts({
        status: status as string,
        authorId: authorId as string,
        categoryId: categoryId as string,
        tags: tags ? (tags as string).split(',') : undefined,
        search: search as string,
        limit: parseInt(limit as string),
        offset: parseInt(offset as string)
      });

      res.json(posts);
    } catch (error) {
      res.status(500).json({ error: error.message });
    }
  }

  async getPost(req: Request, res: Response) {
    try {
      const { slug } = req.params;
      const post = await this.postService.getPost(slug);
      res.json(post);
    } catch (error) {
      res.status(404).json({ error: error.message });
    }
  }

  async getRelatedPosts(req: Request, res: Response) {
    try {
      const { id } = req.params;
      const { limit = 5 } = req.query;
      
      const relatedPosts = await this.postService.getRelatedPosts(
        id,
        parseInt(limit as string)
      );
      
      res.json(relatedPosts);
    } catch (error) {
      res.status(500).json({ error: error.message });
    }
  }

  async createPost(req: Request, res: Response) {
    try {
      const userId = req.user.id;
      const postData = req.body;
      
      const post = await this.postService.createPost({
        ...postData,
        authorId: userId
      });
      
      res.status(201).json(post);
    } catch (error) {
      res.status(500).json({ error: error.message });
    }
  }

  async updatePost(req: Request, res: Response) {
    try {
      const { id } = req.params;
      const postData = req.body;
      
      const post = await this.postService.updatePost(id, postData);
      res.json(post);
    } catch (error) {
      res.status(500).json({ error: error.message });
    }
  }

  async publishPost(req: Request, res: Response) {
    try {
      const { id } = req.params;
      const post = await this.postService.publishPost(id);
      res.json(post);
    } catch (error) {
      res.status(500).json({ error: error.message });
    }
  }

  async deletePost(req: Request, res: Response) {
    try {
      const { id } = req.params;
      await this.query-2jz.delete({ model: 'Post', id });
      res.status(204).send();
    } catch (error) {
      res.status(500).json({ error: error.message });
    }
  }
}

// src/controllers/CommentController.ts
import { Request, Response } from 'express';
import { CommentService } from '../services/CommentService';

export class CommentController {
  constructor(private commentService: CommentService) {}

  async getComments(req: Request, res: Response) {
    try {
      const { postId } = req.params;
      const { status = 'approved' } = req.query;
      
      const comments = await this.commentService.getComments(
        postId,
        status as string
      );
      
      res.json(comments);
    } catch (error) {
      res.status(500).json({ error: error.message });
    }
  }

  async createComment(req: Request, res: Response) {
    try {
      const { postId } = req.params;
      const commentData = {
        ...req.body,
        postId,
        ipAddress: req.ip,
        userAgent: req.get('User-Agent')
      };
      
      const comment = await this.commentService.createComment(commentData);
      res.status(201).json(comment);
    } catch (error) {
      res.status(500).json({ error: error.message });
    }
  }

  async moderateComment(req: Request, res: Response) {
    try {
      const { id } = req.params;
      const { status } = req.body;
      
      const comment = await this.commentService.moderateComment(id, status);
      res.json(comment);
    } catch (error) {
      res.status(500).json({ error: error.message });
    }
  }

  async getPendingComments(req: Request, res: Response) {
    try {
      const { limit = 20, offset = 0 } = req.query;
      
      const comments = await this.commentService.getPendingComments(
        parseInt(limit as string),
        parseInt(offset as string)
      );
      
      res.json(comments);
    } catch (error) {
      res.status(500).json({ error: error.message });
    }
  }

  async bulkModerateComments(req: Request, res: Response) {
    try {
      const { commentIds, status } = req.body;
      
      const comments = await this.commentService.bulkModerateComments(
        commentIds,
        status
      );
      
      res.json(comments);
    } catch (error) {
      res.status(500).json({ error: error.message });
    }
  }
}