@meith/db 0.22.0 → 0.23.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@meith/db",
-  "version": "0.22.0",
+  "version": "0.23.1",
   "license": "MIT",
   "repository": {
     "type": "git",
@@ -22,35 +22,35 @@
   "dependencies": {
     "drizzle-orm": "^0.45.2",
     "postgres": "^3.4.7",
-    "@meith/accounts": "0.22.0",
-    "@meith/admin": "0.22.0",
-    "@meith/antispam": "0.22.0",
-    "@meith/authorization": "0.22.0",
-    "@meith/attachments": "0.22.0",
-    "@meith/api": "0.22.0",
-    "@meith/avatars": "0.22.0",
-    "@meith/core": "0.22.0",
-    "@meith/drafts": "0.22.0",
-    "@meith/events": "0.22.0",
-    "@meith/forums": "0.22.0",
-    "@meith/groups": "0.22.0",
-    "@meith/markdown": "0.22.0",
-    "@meith/i18n": "0.22.0",
-    "@meith/marketplace": "0.22.0",
-    "@meith/messages": "0.22.0",
-    "@meith/moderation": "0.22.0",
-    "@meith/plugin-kit": "0.22.0",
-    "@meith/polls": "0.22.0",
-    "@meith/notifications": "0.22.0",
-    "@meith/relations": "0.22.0",
-    "@meith/profile-fields": "0.22.0",
-    "@meith/settings": "0.22.0",
-    "@meith/search": "0.22.0",
-    "@meith/signatures": "0.22.0",
-    "@meith/threads": "0.22.0",
-    "@meith/tasks": "0.22.0",
-    "@meith/subscriptions": "0.22.0",
-    "@meith/reputation": "0.22.0"
+    "@meith/accounts": "0.23.1",
+    "@meith/admin": "0.23.1",
+    "@meith/antispam": "0.23.1",
+    "@meith/api": "0.23.1",
+    "@meith/attachments": "0.23.1",
+    "@meith/authorization": "0.23.1",
+    "@meith/avatars": "0.23.1",
+    "@meith/core": "0.23.1",
+    "@meith/drafts": "0.23.1",
+    "@meith/events": "0.23.1",
+    "@meith/forums": "0.23.1",
+    "@meith/groups": "0.23.1",
+    "@meith/i18n": "0.23.1",
+    "@meith/markdown": "0.23.1",
+    "@meith/marketplace": "0.23.1",
+    "@meith/messages": "0.23.1",
+    "@meith/moderation": "0.23.1",
+    "@meith/notifications": "0.23.1",
+    "@meith/plugin-kit": "0.23.1",
+    "@meith/polls": "0.23.1",
+    "@meith/profile-fields": "0.23.1",
+    "@meith/relations": "0.23.1",
+    "@meith/reputation": "0.23.1",
+    "@meith/search": "0.23.1",
+    "@meith/settings": "0.23.1",
+    "@meith/signatures": "0.23.1",
+    "@meith/subscriptions": "0.23.1",
+    "@meith/tasks": "0.23.1",
+    "@meith/threads": "0.23.1"
   },
   "devDependencies": {
     "drizzle-kit": "^0.31.6",

package/src/ban-filter-contract.fixture.ts

@@ -0,0 +1,165 @@
+import { describe, expect, it } from 'vitest'
+
+import type { BanFilterAdminRepository } from '@meith/accounts'
+import { BAN_FILTER_PATTERN_MAX, BAN_FILTER_WILDCARD_MAX } from '@meith/accounts'
+import { ValidationError } from '@meith/core'
+
+export const CONTRACT_AUTHOR = 4242
+
+export type BanFilterRepositoryFactory = () => Promise<BanFilterAdminRepository>
+
+export function banFilterRepositoryContract(name: string, make: BanFilterRepositoryFactory): void {
+  describe(`BanFilterAdminRepository contract: ${name}`, () => {
+    it('round-trips the pattern, the note and who added it', async () => {
+      const filters = await make()
+      const id = await filters.create({
+        type: 'email',
+        pattern: '*@blocked.example',
+        note: 'the sign-up wave in March',
+        createdByUserId: CONTRACT_AUTHOR,
+      })
+
+      const stored = await filters.listForAdmin()
+
+      expect(stored).toHaveLength(1)
+      expect(stored[0]).toMatchObject({
+        id,
+        type: 'email',
+        pattern: '*@blocked.example',
+        note: 'the sign-up wave in March',
+        createdByUserId: CONTRACT_AUTHOR,
+      })
+      expect(stored[0]?.createdAt).toBeInstanceOf(Date)
+    })
+
+    it('lists the newest filter first', async () => {
+      const filters = await make()
+      await filters.create({ type: 'username', pattern: 'first*', createdByUserId: null })
+      await filters.create({ type: 'username', pattern: 'second*', createdByUserId: null })
+
+      expect((await filters.listForAdmin()).map((row) => row.pattern)).toEqual([
+        'second*',
+        'first*',
+      ])
+    })
+
+    it('keeps an unwritten note and an unnamed author as null', async () => {
+      const filters = await make()
+      await filters.create({
+        type: 'ip',
+        pattern: '192.0.2.*',
+        note: '   ',
+        createdByUserId: null,
+      })
+
+      expect((await filters.listForAdmin())[0]).toMatchObject({
+        note: null,
+        createdByUserId: null,
+      })
+    })
+
+    it('stores the pattern without the whitespace around it', async () => {
+      const filters = await make()
+      await filters.create({ type: 'username', pattern: '  spammer*  ', createdByUserId: null })
+
+      expect((await filters.listForAdmin())[0]?.pattern).toBe('spammer*')
+    })
+
+    it('refuses a second filter of the same type and pattern', async () => {
+      const filters = await make()
+      await filters.create({ type: 'email', pattern: '*@blocked.example', createdByUserId: null })
+
+      await expect(
+        filters.create({ type: 'email', pattern: '*@blocked.example', createdByUserId: null }),
+      ).rejects.toThrow(ValidationError)
+
+      expect(await filters.listForAdmin()).toHaveLength(1)
+    })
+
+    it('holds the same pattern under a different type', async () => {
+      const filters = await make()
+      await filters.create({ type: 'email', pattern: 'shared*', createdByUserId: null })
+
+      await expect(
+        filters.create({ type: 'username', pattern: 'shared*', createdByUserId: null }),
+      ).resolves.toEqual(expect.any(Number))
+    })
+
+    it('refuses an empty pattern before writing anything', async () => {
+      const filters = await make()
+
+      await expect(
+        filters.create({ type: 'username', pattern: '   ', createdByUserId: null }),
+      ).rejects.toThrow(ValidationError)
+
+      expect(await filters.listForAdmin()).toHaveLength(0)
+    })
+
+    it('refuses a pattern longer than the cap before writing anything', async () => {
+      const filters = await make()
+
+      await expect(
+        filters.create({
+          type: 'username',
+          pattern: 'a'.repeat(BAN_FILTER_PATTERN_MAX + 1),
+          createdByUserId: null,
+        }),
+      ).rejects.toThrow(ValidationError)
+
+      expect(await filters.listForAdmin()).toHaveLength(0)
+    })
+
+    it('refuses a pattern with more wildcards than the cap before writing anything', async () => {
+      const filters = await make()
+
+      await expect(
+        filters.create({
+          type: 'username',
+          pattern: `a${'*a'.repeat(BAN_FILTER_WILDCARD_MAX + 1)}`,
+          createdByUserId: null,
+        }),
+      ).rejects.toThrow(ValidationError)
+
+      expect(await filters.listForAdmin()).toHaveLength(0)
+    })
+
+    it('removes a filter', async () => {
+      const filters = await make()
+      const id = await filters.create({
+        type: 'email',
+        pattern: '*@blocked.example',
+        createdByUserId: null,
+      })
+
+      await filters.remove(id)
+
+      expect(await filters.listForAdmin()).toHaveLength(0)
+      expect(await filters.listAll()).toHaveLength(0)
+    })
+
+    it('treats removing a filter that is already gone as done', async () => {
+      const filters = await make()
+      const id = await filters.create({
+        type: 'email',
+        pattern: '*@blocked.example',
+        createdByUserId: null,
+      })
+
+      await filters.remove(id)
+
+      await expect(filters.remove(id)).resolves.toBeUndefined()
+    })
+
+    it('gives the matcher only what it needs to match on', async () => {
+      const filters = await make()
+      const id = await filters.create({
+        type: 'email',
+        pattern: '*@blocked.example',
+        note: 'a note the matcher has no use for',
+        createdByUserId: CONTRACT_AUTHOR,
+      })
+
+      expect(await filters.listAll()).toEqual([{ id, type: 'email', pattern: '*@blocked.example' }])
+    })
+  })
+}

package/src/ban-repos.ts

@@ -1,13 +1,18 @@
-import { and, asc, eq, isNotNull, isNull, lte, sql } from 'drizzle-orm'
-
-import type {
-  BanFilter,
-  BanFilterRepository,
-  BanFilterType,
-  BanRecord,
-  BanRepository,
-  CreateBanInput,
+import { and, asc, desc, eq, isNotNull, isNull, lte, sql } from 'drizzle-orm'
+
+import {
+  assertUsableFilter,
+  type BanFilter,
+  type BanFilterAdminRepository,
+  type BanFilterRecord,
+  type BanFilterType,
+  type BanRecord,
+  type BanRepository,
+  type CreateBanFilterInput,
+  type CreateBanInput,
 } from '@meith/accounts'
+import { ValidationError } from '@meith/core'
+import { msg } from '@meith/i18n'
 
 import type { Database } from './client'
 import { banFilters, bans, rememberTokens, sessions, users } from './schema'
@@ -133,7 +138,7 @@ export class PostgresBanRepository implements BanRepository {
   }
 }
 
-export class PostgresBanFilterRepository implements BanFilterRepository {
+export class PostgresBanFilterRepository implements BanFilterAdminRepository {
   constructor(private readonly db: Database) {}
 
   async listAll(): Promise<readonly BanFilter[]> {
@@ -143,4 +148,45 @@ export class PostgresBanFilterRepository implements BanFilterRepository {
 
     return rows.map((r) => ({ id: r.id, type: r.type as BanFilterType, pattern: r.pattern }))
   }
+
+  async listForAdmin(): Promise<readonly BanFilterRecord[]> {
+    const rows = await this.db
+      .select({
+        id: banFilters.id,
+        type: banFilters.type,
+        pattern: banFilters.pattern,
+        note: banFilters.note,
+        createdByUserId: banFilters.createdByUserId,
+        createdAt: banFilters.createdAt,
+      })
+      .from(banFilters)
+      .orderBy(desc(banFilters.id))
+
+    return rows.map((r) => ({ ...r, type: r.type as BanFilterType }))
+  }
+
+  async create(input: CreateBanFilterInput): Promise<number> {
+    assertUsableFilter(input.type, input.pattern)
+
+    const note = input.note?.trim()
+
+    const [row] = await this.db
+      .insert(banFilters)
+      .values({
+        type: input.type,
+        pattern: input.pattern.trim(),
+        note: note === undefined || note === '' ? null : note,
+        createdByUserId: input.createdByUserId,
+      })
+      .onConflictDoNothing({ target: [banFilters.type, banFilters.pattern] })
+      .returning({ id: banFilters.id })
+
+    if (row === undefined) throw new ValidationError(msg('error.accounts.ban-filter-already-held'))
+
+    return row.id
+  }
+
+  async remove(id: number): Promise<void> {
+    await this.db.delete(banFilters).where(eq(banFilters.id, id))
+  }
 }