@newcms/database 0.2.0 → 0.3.0

package/dist/index.d.cts

@@ -2692,4 +2692,72 @@ declare class RevisionRepository {
     private hasChanges;
 }
 
-export { type CacheGroupConfig, type CreatePostInput, type CreateTermInput, type Database, type DatabaseConfig, type MetaColumnNames, type MetaEntry, MetaRepository, type MetaTableColumns, ObjectCache, type ObjectCacheConfig, OptionsRepository, PostRepository, type PostRow, RevisionRepository, TaxonomyRepository, type TermRow, type UpdatePostInput, commentmeta, comments, createConnection, links, options, postmeta, posts, scheduledEvents, sessions, termRelationships, termTaxonomy, termmeta, terms, usermeta, users };
+interface CreateCommentInput {
+    commentPostId: number;
+    commentAuthor: string;
+    commentAuthorEmail?: string;
+    commentAuthorUrl?: string;
+    commentAuthorIp?: string;
+    commentContent: string;
+    commentType?: string;
+    commentParent?: number;
+    userId?: number;
+    commentApproved?: string;
+}
+interface CommentRow {
+    commentId: number;
+    commentPostId: number;
+    commentAuthor: string;
+    commentAuthorEmail: string;
+    commentAuthorUrl: string;
+    commentAuthorIp: string;
+    commentDate: Date;
+    commentDateGmt: Date;
+    commentContent: string;
+    commentKarma: number;
+    commentApproved: string;
+    commentAgent: string;
+    commentType: string;
+    commentParent: number;
+    userId: number;
+}
+interface CommentModerationRules {
+    blockedWords?: string[];
+    moderationWords?: string[];
+    maxLinks?: number;
+    floodSeconds?: number;
+}
+declare class CommentRepository {
+    private db;
+    readonly meta: MetaRepository;
+    constructor(db: Database);
+    create(input: CreateCommentInput): Promise<CommentRow>;
+    getById(id: number): Promise<CommentRow | undefined>;
+    getByPost(postId: number, status?: string): Promise<CommentRow[]>;
+    /**
+     * Get threaded comments — returns flat list, client builds the tree
+     * using commentParent references.
+     */
+    getThreaded(postId: number, _depth?: number): Promise<CommentRow[]>;
+    approve(id: number): Promise<boolean>;
+    unapprove(id: number): Promise<boolean>;
+    spam(id: number): Promise<boolean>;
+    trash(id: number): Promise<boolean>;
+    deletePermanently(id: number): Promise<boolean>;
+    /**
+     * Check moderation rules before approving a comment.
+     */
+    moderate(content: string, _authorEmail: string, rules: CommentModerationRules): 'approve' | 'hold' | 'spam';
+    /**
+     * Check for duplicate comment.
+     */
+    isDuplicate(postId: number, authorEmail: string, content: string): Promise<boolean>;
+    /**
+     * Check flood protection — has user commented too recently?
+     */
+    isFlooding(authorIp: string, floodSeconds: number): Promise<boolean>;
+    countByStatus(postId?: number): Promise<Record<string, number>>;
+    private updatePostCommentCount;
+}
+
+export { type CacheGroupConfig, type CommentModerationRules, CommentRepository, type CommentRow, type CreateCommentInput, type CreatePostInput, type CreateTermInput, type Database, type DatabaseConfig, type MetaColumnNames, type MetaEntry, MetaRepository, type MetaTableColumns, ObjectCache, type ObjectCacheConfig, OptionsRepository, PostRepository, type PostRow, RevisionRepository, TaxonomyRepository, type TermRow, type UpdatePostInput, commentmeta, comments, createConnection, links, options, postmeta, posts, scheduledEvents, sessions, termRelationships, termTaxonomy, termmeta, terms, usermeta, users };

package/dist/index.d.ts

@@ -2692,4 +2692,72 @@ declare class RevisionRepository {
     private hasChanges;
 }
 
-export { type CacheGroupConfig, type CreatePostInput, type CreateTermInput, type Database, type DatabaseConfig, type MetaColumnNames, type MetaEntry, MetaRepository, type MetaTableColumns, ObjectCache, type ObjectCacheConfig, OptionsRepository, PostRepository, type PostRow, RevisionRepository, TaxonomyRepository, type TermRow, type UpdatePostInput, commentmeta, comments, createConnection, links, options, postmeta, posts, scheduledEvents, sessions, termRelationships, termTaxonomy, termmeta, terms, usermeta, users };
+interface CreateCommentInput {
+    commentPostId: number;
+    commentAuthor: string;
+    commentAuthorEmail?: string;
+    commentAuthorUrl?: string;
+    commentAuthorIp?: string;
+    commentContent: string;
+    commentType?: string;
+    commentParent?: number;
+    userId?: number;
+    commentApproved?: string;
+}
+interface CommentRow {
+    commentId: number;
+    commentPostId: number;
+    commentAuthor: string;
+    commentAuthorEmail: string;
+    commentAuthorUrl: string;
+    commentAuthorIp: string;
+    commentDate: Date;
+    commentDateGmt: Date;
+    commentContent: string;
+    commentKarma: number;
+    commentApproved: string;
+    commentAgent: string;
+    commentType: string;
+    commentParent: number;
+    userId: number;
+}
+interface CommentModerationRules {
+    blockedWords?: string[];
+    moderationWords?: string[];
+    maxLinks?: number;
+    floodSeconds?: number;
+}
+declare class CommentRepository {
+    private db;
+    readonly meta: MetaRepository;
+    constructor(db: Database);
+    create(input: CreateCommentInput): Promise<CommentRow>;
+    getById(id: number): Promise<CommentRow | undefined>;
+    getByPost(postId: number, status?: string): Promise<CommentRow[]>;
+    /**
+     * Get threaded comments — returns flat list, client builds the tree
+     * using commentParent references.
+     */
+    getThreaded(postId: number, _depth?: number): Promise<CommentRow[]>;
+    approve(id: number): Promise<boolean>;
+    unapprove(id: number): Promise<boolean>;
+    spam(id: number): Promise<boolean>;
+    trash(id: number): Promise<boolean>;
+    deletePermanently(id: number): Promise<boolean>;
+    /**
+     * Check moderation rules before approving a comment.
+     */
+    moderate(content: string, _authorEmail: string, rules: CommentModerationRules): 'approve' | 'hold' | 'spam';
+    /**
+     * Check for duplicate comment.
+     */
+    isDuplicate(postId: number, authorEmail: string, content: string): Promise<boolean>;
+    /**
+     * Check flood protection — has user commented too recently?
+     */
+    isFlooding(authorIp: string, floodSeconds: number): Promise<boolean>;
+    countByStatus(postId?: number): Promise<Record<string, number>>;
+    private updatePostCommentCount;
+}
+
+export { type CacheGroupConfig, type CommentModerationRules, CommentRepository, type CommentRow, type CreateCommentInput, type CreatePostInput, type CreateTermInput, type Database, type DatabaseConfig, type MetaColumnNames, type MetaEntry, MetaRepository, type MetaTableColumns, ObjectCache, type ObjectCacheConfig, OptionsRepository, PostRepository, type PostRow, RevisionRepository, TaxonomyRepository, type TermRow, type UpdatePostInput, commentmeta, comments, createConnection, links, options, postmeta, posts, scheduledEvents, sessions, termRelationships, termTaxonomy, termmeta, terms, usermeta, users };

package/dist/index.js

@@ -1503,7 +1503,161 @@ var RevisionRepository = class {
     return false;
   }
 };
+
+// src/repositories/comment-repository.ts
+import { eq as eq6, and as and5, sql as sql5 } from "drizzle-orm";
+var CommentRepository = class {
+  constructor(db) {
+    this.db = db;
+    const metaCols = {
+      metaId: commentmeta.metaId,
+      objectId: commentmeta.commentId,
+      metaKey: commentmeta.metaKey,
+      metaValue: commentmeta.metaValue,
+      metaValueJson: commentmeta.metaValueJson
+    };
+    const colNames = {
+      table: "commentmeta",
+      sql: { metaId: "meta_id", objectId: "comment_id", metaKey: "meta_key", metaValue: "meta_value", metaValueJson: "meta_value_json" },
+      ts: { metaId: "metaId", objectId: "commentId", metaKey: "metaKey", metaValue: "metaValue", metaValueJson: "metaValueJson" }
+    };
+    this.meta = new MetaRepository(db, commentmeta, metaCols, colNames);
+  }
+  db;
+  meta;
+  async create(input) {
+    const now = /* @__PURE__ */ new Date();
+    const [row] = await this.db.insert(comments).values({
+      commentPostId: input.commentPostId,
+      commentAuthor: input.commentAuthor,
+      commentAuthorEmail: input.commentAuthorEmail ?? "",
+      commentAuthorUrl: input.commentAuthorUrl ?? "",
+      commentAuthorIp: input.commentAuthorIp ?? "",
+      commentContent: input.commentContent,
+      commentType: input.commentType ?? "comment",
+      commentParent: input.commentParent ?? 0,
+      userId: input.userId ?? 0,
+      commentApproved: input.commentApproved ?? "1",
+      commentDate: now,
+      commentDateGmt: now
+    }).returning();
+    await this.updatePostCommentCount(input.commentPostId);
+    return row;
+  }
+  async getById(id) {
+    const rows = await this.db.select().from(comments).where(eq6(comments.commentId, id)).limit(1);
+    return rows[0];
+  }
+  async getByPost(postId, status) {
+    const conditions = [eq6(comments.commentPostId, postId)];
+    if (status) conditions.push(eq6(comments.commentApproved, status));
+    return await this.db.select().from(comments).where(and5(...conditions)).orderBy(comments.commentDate);
+  }
+  /**
+   * Get threaded comments — returns flat list, client builds the tree
+   * using commentParent references.
+   */
+  async getThreaded(postId, _depth = 5) {
+    return this.getByPost(postId, "1");
+  }
+  async approve(id) {
+    const comment = await this.getById(id);
+    if (!comment) return false;
+    await this.db.update(comments).set({ commentApproved: "1" }).where(eq6(comments.commentId, id));
+    await this.updatePostCommentCount(comment.commentPostId);
+    return true;
+  }
+  async unapprove(id) {
+    const comment = await this.getById(id);
+    if (!comment) return false;
+    await this.db.update(comments).set({ commentApproved: "0" }).where(eq6(comments.commentId, id));
+    await this.updatePostCommentCount(comment.commentPostId);
+    return true;
+  }
+  async spam(id) {
+    const comment = await this.getById(id);
+    if (!comment) return false;
+    await this.db.update(comments).set({ commentApproved: "spam" }).where(eq6(comments.commentId, id));
+    await this.updatePostCommentCount(comment.commentPostId);
+    return true;
+  }
+  async trash(id) {
+    const comment = await this.getById(id);
+    if (!comment) return false;
+    await this.meta.update(id, "_trash_status", comment.commentApproved);
+    await this.db.update(comments).set({ commentApproved: "trash" }).where(eq6(comments.commentId, id));
+    await this.updatePostCommentCount(comment.commentPostId);
+    return true;
+  }
+  async deletePermanently(id) {
+    const comment = await this.getById(id);
+    if (!comment) return false;
+    await this.meta.deleteAllForObject(id);
+    const result = await this.db.delete(comments).where(eq6(comments.commentId, id)).returning({ commentId: comments.commentId });
+    if (result.length > 0) await this.updatePostCommentCount(comment.commentPostId);
+    return result.length > 0;
+  }
+  /**
+   * Check moderation rules before approving a comment.
+   */
+  moderate(content, _authorEmail, rules) {
+    const lower = content.toLowerCase();
+    if (rules.blockedWords) {
+      for (const word of rules.blockedWords) {
+        if (lower.includes(word.toLowerCase())) return "spam";
+      }
+    }
+    if (rules.moderationWords) {
+      for (const word of rules.moderationWords) {
+        if (lower.includes(word.toLowerCase())) return "hold";
+      }
+    }
+    if (rules.maxLinks !== void 0) {
+      const linkCount = (content.match(/https?:\/\//g) ?? []).length;
+      if (linkCount > rules.maxLinks) return "hold";
+    }
+    return "approve";
+  }
+  /**
+   * Check for duplicate comment.
+   */
+  async isDuplicate(postId, authorEmail, content) {
+    const rows = await this.db.select({ commentId: comments.commentId }).from(comments).where(
+      and5(
+        eq6(comments.commentPostId, postId),
+        eq6(comments.commentAuthorEmail, authorEmail),
+        eq6(comments.commentContent, content)
+      )
+    ).limit(1);
+    return rows.length > 0;
+  }
+  /**
+   * Check flood protection — has user commented too recently?
+   */
+  async isFlooding(authorIp, floodSeconds) {
+    const cutoff = new Date(Date.now() - floodSeconds * 1e3);
+    const rows = await this.db.select({ commentId: comments.commentId }).from(comments).where(
+      and5(
+        eq6(comments.commentAuthorIp, authorIp),
+        sql5`${comments.commentDate} > ${cutoff}`
+      )
+    ).limit(1);
+    return rows.length > 0;
+  }
+  async countByStatus(postId) {
+    const conditions = postId !== void 0 ? [eq6(comments.commentPostId, postId)] : [];
+    const rows = await this.db.select({ status: comments.commentApproved, count: sql5`count(*)::int` }).from(comments).where(conditions.length > 0 ? and5(...conditions) : void 0).groupBy(comments.commentApproved);
+    const result = {};
+    for (const row of rows) result[row.status] = row.count;
+    return result;
+  }
+  async updatePostCommentCount(postId) {
+    const [result] = await this.db.select({ count: sql5`count(*)::int` }).from(comments).where(and5(eq6(comments.commentPostId, postId), eq6(comments.commentApproved, "1")));
+    await this.db.update(posts).set({ commentCount: result.count }).where(eq6(posts.id, postId));
+  }
+};
 export {
+  CommentRepository,
   MetaRepository,
   ObjectCache,
   OptionsRepository,