feat(comment): hide most of info in archived/banned comments

schema.graphql

@@ -1364,7 +1364,7 @@ type Comment implements Node {
   content: String
 
   """Author of this comment."""
-  author: User!
+  author: User
 
   """This value determines this comment is pinned or not."""
   pinned: Boolean!
@@ -1392,7 +1392,7 @@ type Comment implements Node {
   remark: String
 
   """Current comment belongs to which Node."""
-  node: Node!
+  node: Node
 }
 
 type CommentConnection implements Connection {

src/definitions/schema.d.ts

@@ -888,7 +888,7 @@ export type GQLCollectionEdge = {
 export type GQLComment = GQLNode & {
   __typename?: 'Comment'
   /** Author of this comment. */
-  author: GQLUser
+  author?: Maybe<GQLUser>
   /** Descendant comments of this comment. */
   comments: GQLCommentConnection
   /** Content of this comment. */
@@ -907,7 +907,7 @@ export type GQLComment = GQLNode & {
   /** The value determines current user's vote. */
   myVote?: Maybe<GQLVote>
   /** Current comment belongs to which Node. */
-  node: GQLNode
+  node?: Maybe<GQLNode>
   /** Parent comment of this comment. */
   parentComment?: Maybe<GQLComment>
   /** This value determines this comment is pinned or not. */
@@ -6056,7 +6056,7 @@ export type GQLCommentResolvers<
   ContextType = Context,
   ParentType extends GQLResolversParentTypes['Comment'] = GQLResolversParentTypes['Comment']
 > = ResolversObject<{
-  author?: Resolver<GQLResolversTypes['User'], ParentType, ContextType>
+  author?: Resolver<Maybe<GQLResolversTypes['User']>, ParentType, ContextType>
   comments?: Resolver<
     GQLResolversTypes['CommentConnection'],
     ParentType,
@@ -6073,7 +6073,7 @@ export type GQLCommentResolvers<
   fromDonator?: Resolver<GQLResolversTypes['Boolean'], ParentType, ContextType>
   id?: Resolver<GQLResolversTypes['ID'], ParentType, ContextType>
   myVote?: Resolver<Maybe<GQLResolversTypes['Vote']>, ParentType, ContextType>
-  node?: Resolver<GQLResolversTypes['Node'], ParentType, ContextType>
+  node?: Resolver<Maybe<GQLResolversTypes['Node']>, ParentType, ContextType>
   parentComment?: Resolver<
     Maybe<GQLResolversTypes['Comment']>,
     ParentType,

src/mutations/comment/deleteComment.ts

@@ -1,4 +1,4 @@
-import type { GQLMutationResolvers } from 'definitions'
+import type { GQLMutationResolvers, Article } from 'definitions'
 
 import {
   CACHE_KEYWORD,
@@ -31,10 +31,10 @@ const resolver: GQLMutationResolvers['deleteComment'] = async (
   const comment = await commentService.loadById(dbId)
 
   // check target
-  let article: any
+  let article: Article | undefined
   let circle: any
   if (comment.type === COMMENT_TYPE.article) {
-    article = await articleService.dataloader.load(comment.targetId)
+    article = await articleService.loadById(comment.targetId)
   } else {
     circle = await atomService.circleIdLoader.load(comment.targetId)
   }

src/queries/comment/author.ts

@@ -1,9 +1,20 @@
 import type { GQLCommentResolvers } from 'definitions'
 
+import { COMMENT_STATE } from 'common/enums'
+
 const resolver: GQLCommentResolvers['author'] = (
-  { authorId },
+  { authorId, state },
   _,
-  { dataSources: { userService } }
-) => userService.loadById(authorId)
+  { viewer, dataSources: { userService } }
+) => {
+  const isActive = state === COMMENT_STATE.active
+  const isCollapsed = state === COMMENT_STATE.collapsed
+  const isAdmin = viewer.hasRole('admin')
+  if (isActive || isCollapsed || isAdmin) {
+    return userService.loadById(authorId)
+  } else {
+    return null
+  }
+}
 
 export default resolver

src/queries/comment/content.ts

@@ -8,7 +8,7 @@ const resolver: GQLCommentResolvers['content'] = (
   { viewer }
 ) => {
   const isActive = state === COMMENT_STATE.active
-  const isCollapsed = state === 'collapsed'
+  const isCollapsed = state === COMMENT_STATE.collapsed
   const isAdmin = viewer.hasRole('admin')
 
   if (isActive || isCollapsed || isAdmin) {

src/queries/comment/createdAt.ts

@@ -0,0 +1,21 @@
+import type { GQLCommentResolvers } from 'definitions'
+
+import { COMMENT_STATE } from 'common/enums'
+
+const resolver: GQLCommentResolvers['createdAt'] = (
+  { createdAt, state },
+  _,
+  { viewer }
+) => {
+  const isActive = state === COMMENT_STATE.active
+  const isCollapsed = state === COMMENT_STATE.collapsed
+  const isAdmin = viewer.hasRole('admin')
+  if (isActive || isCollapsed || isAdmin) {
+    return createdAt
+  } else {
+    // invalid date
+    return new Date(0)
+  }
+}
+
+export default resolver

src/queries/comment/downvotes.ts

@@ -1,9 +1,5 @@
 import type { GQLCommentResolvers } from 'definitions'
 
-const resolver: GQLCommentResolvers['downvotes'] = (
-  { id },
-  _,
-  { dataSources: { commentService } }
-) => 0
+const resolver: GQLCommentResolvers['downvotes'] = () => 0
 
 export default resolver

src/queries/comment/fromDonator.ts

@@ -2,36 +2,43 @@ import type { GQLCommentResolvers } from 'definitions'
 
 import {
   COMMENT_TYPE,
+  COMMENT_STATE,
   TRANSACTION_PURPOSE,
   TRANSACTION_STATE,
   TRANSACTION_TARGET_TYPE,
 } from 'common/enums'
 
 const resolver: GQLCommentResolvers['fromDonator'] = async (
-  { authorId, targetId, type },
+  { authorId, targetId, type, state },
   _,
-  { dataSources: { atomService, articleService } }
+  { viewer, dataSources: { atomService, articleService } }
 ) => {
   if (!targetId || type !== COMMENT_TYPE.article) {
     return false
   }
 
-  const { id: entityTypeId } = await articleService.baseFindEntityTypeId(
-    TRANSACTION_TARGET_TYPE.article
-  )
+  const isActive = state === COMMENT_STATE.active
+  const isCollapsed = state === COMMENT_STATE.collapsed
+  const isAdmin = viewer.hasRole('admin')
+  if (isActive || isCollapsed || isAdmin) {
+    const { id: entityTypeId } = await articleService.baseFindEntityTypeId(
+      TRANSACTION_TARGET_TYPE.article
+    )
+    const record = await atomService.findFirst({
+      table: 'transaction',
+      where: {
+        targetId,
+        targetType: entityTypeId,
+        senderId: authorId,
+        state: TRANSACTION_STATE.succeeded,
+        purpose: TRANSACTION_PURPOSE.donation,
+      },
+    })
 
-  const record = await atomService.findFirst({
-    table: 'transaction',
-    where: {
-      targetId,
-      targetType: entityTypeId,
-      senderId: authorId,
-      state: TRANSACTION_STATE.succeeded,
-      purpose: TRANSACTION_PURPOSE.donation,
-    },
-  })
-
-  return !!record
+    return !!record
+  } else {
+    return false
+  }
 }
 
 export default resolver

src/queries/comment/index.ts

@@ -18,6 +18,7 @@ import circleDiscussionThreadCount from './circle/discussionThreadCount'
 import circlePinnedBroadcast from './circle/pinnedBroadcast'
 import comments from './comments'
 import content from './content'
+import createdAt from './createdAt'
 import downvotes from './downvotes'
 import fromDonator from './fromDonator'
 import myVote from './myVote'
@@ -53,6 +54,7 @@ export default {
     fromDonator,
     type: ({ type }: { type: string }) => COMMENT_TYPES_REVERSED[type],
     node,
+    createdAt,
   },
   Circle: {
     broadcast: circleBroadcast,

src/queries/comment/replyTo.ts

@@ -1,9 +1,20 @@
 import type { GQLCommentResolvers } from 'definitions'
 
+import { COMMENT_STATE } from 'common/enums'
+
 const resolver: GQLCommentResolvers['replyTo'] = (
-  { replyTo },
+  { replyTo, state },
   _,
-  { dataSources: { commentService } }
-) => (replyTo ? commentService.loadById(replyTo) : null)
+  { viewer, dataSources: { commentService } }
+) => {
+  const isActive = state === COMMENT_STATE.active
+  const isCollapsed = state === COMMENT_STATE.collapsed
+  const isAdmin = viewer.hasRole('admin')
+  if (isActive || isCollapsed || isAdmin) {
+    return replyTo ? commentService.loadById(replyTo) : null
+  } else {
+    return null
+  }
+}
 
 export default resolver

src/queries/comment/upvotes.ts

@@ -1,9 +1,20 @@
 import type { GQLCommentResolvers } from 'definitions'
 
+import { COMMENT_STATE } from 'common/enums'
+
 const resolver: GQLCommentResolvers['upvotes'] = (
-  { id, upvotes }: any,
+  { id, state },
   _,
-  { dataSources: { commentService } }
-) => parseInt(upvotes, 10) || commentService.countUpVote(id)
+  { viewer, dataSources: { commentService } }
+) => {
+  const isActive = state === COMMENT_STATE.active
+  const isCollapsed = state === COMMENT_STATE.collapsed
+  const isAdmin = viewer.hasRole('admin')
+  if (isActive || isCollapsed || isAdmin) {
+    return commentService.countUpVote(id)
+  } else {
+    return 0
+  }
+}
 
 export default resolver

src/types/__test__/2/comment.test.ts

@@ -79,8 +79,20 @@ const GET_COMMENT = /* GraphQL */ `
   query ($input: NodeInput!) {
     node(input: $input) {
       ... on Comment {
+        state
+        type
+        createdAt
+        content
+        author {
+          id
+        }
+        pinned
         upvotes
         downvotes
+        myVote
+        replyTo {
+          id
+        }
       }
     }
   }
@@ -116,6 +128,58 @@ const getCommentVotes = async (commentId: string) => {
   return data && data.node
 }
 
+describe('query comment', () => {
+  test('query comment by id', async () => {
+    const server = await testClient({ connections })
+    const {
+      data: { node },
+      errors,
+    } = await server.executeOperation({
+      query: GET_COMMENT,
+      variables: {
+        input: { id: COMMENT_ID },
+      },
+    })
+    expect(node.state).toBe('active')
+    expect(node.type).toBe('article')
+    expect(node.createdAt.toString()).not.toBe(new Date(0).toString())
+    expect(node.content).not.toBe('')
+    expect(node.author).not.toBeNull()
+    expect(errors).toBeUndefined()
+  })
+  test('query archived comment', async () => {
+    await connections
+      .knex('comment')
+      .where({ id: 1 })
+      .update({ state: 'archived' })
+    const server = await testClient({ connections })
+    const {
+      data: { node },
+      errors,
+    } = await server.executeOperation({
+      query: GET_COMMENT,
+      variables: {
+        input: { id: COMMENT_ID },
+      },
+    })
+    expect(node.state).toBe('archived')
+    expect(node.type).toBe('article')
+    expect(node.createdAt.toString()).toBe(new Date(0).toString())
+    expect(node.content).toBe('')
+    expect(node.author).toBeNull()
+    expect(node.pinned).toBe(false)
+    expect(node.upvotes).toBe(0)
+    expect(node.downvotes).toBe(0)
+    expect(node.replyTo).toBeNull()
+    expect(errors).toBeUndefined()
+
+    await connections
+      .knex('comment')
+      .where({ id: 1 })
+      .update({ state: 'active' })
+  })
+})
+
 describe('query comment list on article', () => {
   test('query comments by author', async () => {
     const authorId = toGlobalId({ type: NODE_TYPES.User, id: 2 })

src/types/comment.ts

@@ -53,7 +53,7 @@ export default /* GraphQL */ `
     content: String
 
     "Author of this comment."
-    author: User! @logCache(type: "${NODE_TYPES.User}")
+    author: User @logCache(type: "${NODE_TYPES.User}")
 
     "This value determines this comment is pinned or not."
     pinned: Boolean!
@@ -82,7 +82,7 @@ export default /* GraphQL */ `
     remark: String @auth(mode: "${AUTH_MODE.admin}")
 
     "Current comment belongs to which Node."
-    node: Node! @logCache(type: "${NODE_TYPES.Node}")
+    node: Node @logCache(type: "${NODE_TYPES.Node}")
   }
 
   extend type Article {