@meith/moderation 0.16.0

package/src/surgery.ts

@@ -0,0 +1,175 @@
+import { ValidationError } from '@meith/core'
+import { msg } from '@meith/i18n'
+
+export interface SurgeryThread {
+  readonly id: number
+  readonly forumId: number
+  readonly slug: string
+  readonly title: string
+  readonly visibility: 'visible' | 'unapproved' | 'deleted'
+  readonly firstPostId: number | null
+  readonly visiblePosts: number
+}
+
+export interface SplitPlan {
+  readonly sourceThreadId: number
+  readonly title: string
+  readonly postIds: readonly number[]
+}
+
+export interface MergePlan {
+  readonly sourceThreadId: number
+  readonly targetThreadId: number
+}
+
+export interface SurgeryOutcome {
+  readonly threadId: number
+  readonly slug: string
+  readonly posts: number
+}
+
+export interface ThreadSurgeryRepository {
+  find(threadId: number): Promise<SurgeryThread | null>
+
+  postsFrom(threadId: number, fromPostId: number): Promise<readonly number[]>
+
+  visiblePostIdsIn(threadId: number, postIds: readonly number[]): Promise<readonly number[]>
+
+  split(plan: SplitPlan & { actorUserId: number; at: Date }): Promise<SurgeryOutcome>
+
+  merge(plan: MergePlan & { actorUserId: number; at: Date }): Promise<SurgeryOutcome>
+}
+
+export interface SurgeryRights {
+  readonly merge: boolean
+  readonly split: boolean
+}
+
+export class ThreadSurgery {
+  private readonly threads: ThreadSurgeryRepository
+  private readonly now: () => Date
+
+  constructor(deps: { threads: ThreadSurgeryRepository; now?: () => Date }) {
+    this.threads = deps.threads
+    this.now = deps.now ?? (() => new Date())
+  }
+
+  async split(input: {
+    readonly threadId: number
+    readonly fromPostId: number
+    readonly title: string
+    readonly actorUserId: number
+    readonly rights: SurgeryRights
+  }): Promise<SurgeryOutcome> {
+    if (!input.rights.split) throw new ValidationError(msg('error.moderation.split-threads-here'))
+
+    const source = await this.requireLive(input.threadId)
+
+    const title = this.requireTitle(input.title)
+
+    if (source.firstPostId !== null && input.fromPostId === source.firstPostId) {
+      throw new ValidationError(msg('error.moderation.whole-thread-move-instead-splitting'))
+    }
+
+    const postIds = await this.threads.postsFrom(input.threadId, input.fromPostId)
+    if (postIds.length === 0) {
+      throw new ValidationError(msg('error.moderation.post-thread'))
+    }
+    if (postIds.length >= source.visiblePosts) {
+      throw new ValidationError(msg('error.moderation.whole-thread-move-instead-splitting'))
+    }
+
+    return this.threads.split({
+      sourceThreadId: source.id,
+      title,
+      postIds,
+      actorUserId: input.actorUserId,
+      at: this.now(),
+    })
+  }
+
+  async splitPosts(input: {
+    readonly threadId: number
+    readonly postIds: readonly number[]
+    readonly title: string
+    readonly actorUserId: number
+    readonly rights: SurgeryRights
+  }): Promise<SurgeryOutcome & { readonly dropped: number }> {
+    if (!input.rights.split) throw new ValidationError(msg('error.moderation.split-threads-here'))
+
+    const source = await this.requireLive(input.threadId)
+    const title = this.requireTitle(input.title)
+
+    if (input.postIds.length === 0) {
+      throw new ValidationError(msg('error.moderation.select-posts-split-out'))
+    }
+
+    const eligible = await this.threads.visiblePostIdsIn(input.threadId, input.postIds)
+    const dropped = new Set(input.postIds).size - eligible.length
+
+    if (eligible.length === 0) {
+      throw new ValidationError(msg('error.moderation.none-those-posts-thread'))
+    }
+    if (source.firstPostId !== null && eligible.includes(source.firstPostId)) {
+      throw new ValidationError(msg('error.moderation.selection-includes-opening-post-move'))
+    }
+    if (eligible.length >= source.visiblePosts) {
+      throw new ValidationError(msg('error.moderation.whole-thread-move-instead-splitting'))
+    }
+
+    const outcome = await this.threads.split({
+      sourceThreadId: source.id,
+      title,
+      postIds: eligible,
+      actorUserId: input.actorUserId,
+      at: this.now(),
+    })
+    return { ...outcome, dropped }
+  }
+
+  async merge(input: {
+    readonly sourceThreadId: number
+    readonly targetThreadId: number
+    readonly actorUserId: number
+    readonly rights: SurgeryRights
+    readonly targetRights: SurgeryRights
+  }): Promise<SurgeryOutcome> {
+    if (!input.rights.merge) throw new ValidationError(msg('error.moderation.merge-threads-here'))
+
+    if (input.sourceThreadId === input.targetThreadId) {
+      throw new ValidationError(msg('error.moderation.thread-merged-into-itself'))
+    }
+
+    const source = await this.requireLive(input.sourceThreadId)
+    const target = await this.requireLive(input.targetThreadId)
+
+    if (!input.targetRights.merge) {
+      throw new ValidationError(msg('error.moderation.merge-threads-into-forum'))
+    }
+
+    return this.threads.merge({
+      sourceThreadId: source.id,
+      targetThreadId: target.id,
+      actorUserId: input.actorUserId,
+      at: this.now(),
+    })
+  }
+
+  private requireTitle(raw: string): string {
+    const title = raw.trim()
+    if (title.length < 3) throw new ValidationError(msg('error.moderation.new-thread-needs-title'))
+    if (title.length > 150) {
+      throw new ValidationError(msg('error.moderation.title-at-most-150-characters'))
+    }
+    return title
+  }
+
+  private async requireLive(threadId: number): Promise<SurgeryThread> {
+    const thread = await this.threads.find(threadId)
+    if (thread === null) throw new ValidationError(msg('error.moderation.thread-exist'))
+    if (thread.visibility !== 'visible') {
+      throw new ValidationError(msg('error.moderation.thread-board'))
+    }
+    return thread
+  }
+}

package/src/thread-tools.ts

@@ -0,0 +1,295 @@
+import { ValidationError } from '@meith/core'
+import { msg } from '@meith/i18n'
+
+export type ThreadTool =
+  | 'lock'
+  | 'unlock'
+  | 'stick'
+  | 'unstick'
+  | 'move'
+  | 'copy'
+  | 'delete'
+  | 'restore'
+
+export interface ThreadToolTarget {
+  readonly id: number
+  readonly forumId: number
+  readonly slug: string
+  readonly title: string
+  readonly isLocked: boolean
+  readonly isSticky: boolean
+  readonly visibility: 'visible' | 'unapproved' | 'deleted'
+}
+
+export interface MoveDestination {
+  readonly id: number
+  readonly type: 'category' | 'forum' | 'link'
+  readonly allowThreads: boolean
+}
+
+export function keepsThreads(destination: MoveDestination): boolean {
+  return (
+    destination.type === 'forum' || (destination.type === 'category' && destination.allowThreads)
+  )
+}
+
+export interface ThreadToolRights {
+  readonly lock: boolean
+  readonly stick: boolean
+  readonly move: boolean
+  readonly delete: boolean
+  readonly restore: boolean
+}
+
+export interface ThreadToolOutcome {
+  readonly tool: ThreadTool
+  readonly threadId: number
+  readonly slug: string
+  readonly changed: boolean
+}
+
+export interface ThreadToolsRepository {
+  find(threadId: number): Promise<ThreadToolTarget | null>
+  findDestination(forumId: number): Promise<MoveDestination | null>
+
+  setLocked(input: {
+    readonly threadId: number
+    readonly locked: boolean
+    readonly actorUserId: number
+    readonly at: Date
+  }): Promise<boolean>
+
+  setSticky(input: {
+    readonly threadId: number
+    readonly sticky: boolean
+    readonly actorUserId: number
+    readonly at: Date
+  }): Promise<boolean>
+
+  setVisibility(input: {
+    readonly threadId: number
+    readonly from: 'visible' | 'deleted'
+    readonly to: 'visible' | 'deleted'
+    readonly actorUserId: number
+    readonly at: Date
+  }): Promise<boolean>
+
+  move(input: {
+    readonly threadId: number
+    readonly fromForumId: number
+    readonly toForumId: number
+    readonly actorUserId: number
+    readonly at: Date
+  }): Promise<boolean>
+
+  copy(input: {
+    readonly threadId: number
+    readonly toForumId: number
+    readonly actorUserId: number
+    readonly at: Date
+  }): Promise<{ threadId: number; slug: string; posts: number }>
+}
+
+export class ThreadTools {
+  private readonly threads: ThreadToolsRepository
+  private readonly now: () => Date
+
+  constructor(deps: { threads: ThreadToolsRepository; now?: () => Date }) {
+    this.threads = deps.threads
+    this.now = deps.now ?? (() => new Date())
+  }
+
+  async apply(input: {
+    readonly threadId: number
+    readonly tool: ThreadTool
+    readonly toForumId?: number | undefined
+    readonly actorUserId: number
+    readonly rights: ThreadToolRights
+    readonly destinationRights?: ThreadToolRights | undefined
+  }): Promise<ThreadToolOutcome> {
+    const target = await this.threads.find(input.threadId)
+    if (target === null) throw new ValidationError(msg('error.moderation.thread-exist'))
+
+    const at = this.now()
+    const base = { threadId: target.id, slug: target.slug }
+
+    switch (input.tool) {
+      case 'lock':
+      case 'unlock': {
+        this.require(input.rights.lock, 'open and close threads')
+        this.requireLive(target)
+        const locked = input.tool === 'lock'
+        return {
+          ...base,
+          tool: input.tool,
+          changed: await this.threads.setLocked({
+            threadId: target.id,
+            locked,
+            actorUserId: input.actorUserId,
+            at,
+          }),
+        }
+      }
+
+      case 'stick':
+      case 'unstick': {
+        this.require(input.rights.stick, 'pin threads')
+        this.requireLive(target)
+        return {
+          ...base,
+          tool: input.tool,
+          changed: await this.threads.setSticky({
+            threadId: target.id,
+            sticky: input.tool === 'stick',
+            actorUserId: input.actorUserId,
+            at,
+          }),
+        }
+      }
+
+      case 'delete': {
+        this.require(input.rights.delete, 'delete threads')
+        if (target.visibility !== 'visible') {
+          throw new ValidationError(msg('error.moderation.thread-board'))
+        }
+        return {
+          ...base,
+          tool: input.tool,
+          changed: await this.threads.setVisibility({
+            threadId: target.id,
+            from: 'visible',
+            to: 'deleted',
+            actorUserId: input.actorUserId,
+            at,
+          }),
+        }
+      }
+
+      case 'restore': {
+        this.require(input.rights.restore, 'restore threads')
+        if (target.visibility !== 'deleted') {
+          throw new ValidationError(msg('error.moderation.thread-deleted'))
+        }
+        return {
+          ...base,
+          tool: input.tool,
+          changed: await this.threads.setVisibility({
+            threadId: target.id,
+            from: 'deleted',
+            to: 'visible',
+            actorUserId: input.actorUserId,
+            at,
+          }),
+        }
+      }
+
+      case 'move':
+        return { ...base, tool: 'move', changed: await this.moveTo(input, target, at) }
+
+      case 'copy': {
+        const copied = await this.copyTo(input, target, at)
+        return {
+          tool: 'copy',
+          threadId: copied.threadId,
+          slug: copied.slug,
+          changed: true,
+        }
+      }
+    }
+  }
+
+  private async moveTo(
+    input: {
+      readonly toForumId?: number | undefined
+      readonly actorUserId: number
+      readonly rights: ThreadToolRights
+      readonly destinationRights?: ThreadToolRights | undefined
+    },
+    target: ThreadToolTarget,
+    at: Date,
+  ): Promise<boolean> {
+    this.require(input.rights.move, 'move threads')
+    this.requireLive(target)
+
+    if (input.toForumId === undefined) {
+      throw new ValidationError(msg('error.moderation.choose-forum-move'))
+    }
+    if (input.toForumId === target.forumId) {
+      throw new ValidationError(msg('error.moderation.thread-already-forum'))
+    }
+
+    if (input.destinationRights?.move !== true) {
+      throw new ValidationError(msg('error.moderation.move-threads-into-forum'))
+    }
+
+    const destination = await this.threads.findDestination(input.toForumId)
+    if (destination === null || !keepsThreads(destination)) {
+      throw new ValidationError(msg('error.moderation.forum-threads-live'))
+    }
+
+    return this.threads.move({
+      threadId: target.id,
+      fromForumId: target.forumId,
+      toForumId: input.toForumId,
+      actorUserId: input.actorUserId,
+      at,
+    })
+  }
+
+  private async copyTo(
+    input: {
+      readonly toForumId?: number | undefined
+      readonly actorUserId: number
+      readonly rights: ThreadToolRights
+      readonly destinationRights?: ThreadToolRights | undefined
+    },
+    target: ThreadToolTarget,
+    at: Date,
+  ): Promise<{ threadId: number; slug: string }> {
+    this.require(input.rights.move, 'copy threads')
+    this.requireLive(target)
+
+    if (input.toForumId === undefined) {
+      throw new ValidationError(msg('error.moderation.choose-forum-copy'))
+    }
+    if (input.destinationRights?.move !== true) {
+      throw new ValidationError(msg('error.moderation.copy-threads-into-forum'))
+    }
+
+    const destination = await this.threads.findDestination(input.toForumId)
+    if (destination === null || !keepsThreads(destination)) {
+      throw new ValidationError(msg('error.moderation.forum-threads-live'))
+    }
+
+    return this.threads.copy({
+      threadId: target.id,
+      toForumId: input.toForumId,
+      actorUserId: input.actorUserId,
+      at,
+    })
+  }
+
+  private require(held: boolean, what: string): void {
+    if (!held) throw new ValidationError(`You cannot ${what} here.`)
+  }
+
+  private requireLive(target: ThreadToolTarget): void {
+    if (target.visibility !== 'visible') {
+      throw new ValidationError(msg('error.moderation.thread-board'))
+    }
+  }
+}
+
+export function parseThreadTool(value: string | undefined): ThreadTool | null {
+  const tools: readonly ThreadTool[] = [
+    'lock',
+    'unlock',
+    'stick',
+    'unstick',
+    'move',
+    'copy',
+    'delete',
+    'restore',
+  ]
+  return tools.includes(value as ThreadTool) ? (value as ThreadTool) : null
+}