@meith/db 0.21.2 → 0.23.0

package/migrations/meta/_journal.json

@@ -407,6 +407,13 @@
       "when": 1787650466674,
       "tag": "0057_promotion_scan_cursor",
       "breakpoints": true
+    },
+    {
+      "idx": 58,
+      "version": "7",
+      "when": 1787771682008,
+      "tag": "0058_mass_mail_opt_in",
+      "breakpoints": true
     }
   ]
 }

package/package.json

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

package/src/attachment-admin-repo.ts

@@ -31,7 +31,6 @@ export interface AttachmentAdminFilter {
 export interface AttachmentAdminPage {
   readonly rows: readonly AttachmentAdminRow[]
   readonly nextBeforeId: number | null
-  /** How many attachments the filter matches, whichever page was asked for. */
   readonly total: number
 }
 

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))
+  }
 }

package/src/marketplace-repo.ts

@@ -32,12 +32,6 @@ function toCached(row: Row | undefined): CachedMarketplace {
   }
 }
 
-/**
- * The single-row cache behind the Browse tab — see the `marketplace_catalog`
- * table comment in `packages/db/src/schema/platform.ts` for why a table
- * rather than the generic `settings` store: this holds a whole feed
- * document and fetch bookkeeping, not a board-operator preference.
- */
 export class PostgresMarketplaceCacheRepository implements MarketplaceCacheRepository {
   constructor(private readonly db: Database) {}
 

package/src/member-settings-repo.ts

@@ -18,6 +18,7 @@ interface RawSettings {
   website: string | null
   bio: string | null
   display_group_id: number | null
+  mass_mail_opt_in_at: Date | string | null
 }
 
 interface RawGroupChoice {
@@ -34,7 +35,8 @@ export class PostgresMemberSettingsRepository implements MemberSettingsRepositor
     const rows = resultRows(
       await this.db.execute(sql`
         select id, email, timezone, locale, posts_per_page, threads_per_page,
-               invisible, location, website, bio, display_group_id
+               invisible, location, website, bio, display_group_id,
+               mass_mail_opt_in_at
           from users
          where id = ${userId} and state <> 'deleted'
       `),
@@ -55,6 +57,7 @@ export class PostgresMemberSettingsRepository implements MemberSettingsRepositor
       website: row.website,
       bio: row.bio,
       displayGroupId: row.display_group_id === null ? null : Number(row.display_group_id),
+      massMailOptInAt: row.mass_mail_opt_in_at === null ? null : new Date(row.mass_mail_opt_in_at),
     }
   }
 
@@ -133,6 +136,20 @@ export class PostgresMemberSettingsRepository implements MemberSettingsRepositor
     `)
   }
 
+  async saveMassMailOptIn(input: {
+    readonly userId: number
+    readonly optIn: boolean
+  }): Promise<void> {
+    const consent = input.optIn ? sql`coalesce(mass_mail_opt_in_at, now())` : sql`null`
+
+    await this.db.execute(sql`
+      update users
+         set mass_mail_opt_in_at = ${consent},
+             updated_at = now()
+       where id = ${input.userId} and state <> 'deleted'
+    `)
+  }
+
   async adoptEmail(input: {
     readonly userId: number
     readonly email: string

package/src/navigation-repo.ts

@@ -28,12 +28,10 @@ export interface NavigationItemRow {
   readonly visibleToGroups: readonly number[]
 }
 
-/** A navigation item a plugin declares, already namespaced by the host. */
 export interface PluginNavigationRow {
   readonly key: string
   readonly href: string
   readonly audience: NavigationAudience
-  /** The key of the sibling row this one is created under, if any. */
   readonly parentKey: string | null
 }
 
@@ -95,13 +93,6 @@ export class PostgresNavigationRepository {
     return rows.map(toRow)
   }
 
-  /**
-   * Bring the plugin-owned rows into line with what the installed plugins ask
-   * for. An item's row is created once and then belongs to the operator: its
-   * label, order, nesting, audience and visibility survive every redeploy,
-   * because only the address a plugin owns is refreshed here. A row whose
-   * plugin is gone goes with it.
-   */
   async syncPluginItems(declared: readonly PluginNavigationRow[]): Promise<{
     readonly added: readonly string[]
     readonly removed: readonly string[]

package/src/pglite.fixture.ts

@@ -17,16 +17,10 @@ export interface QueryLog {
 export interface TestDb {
   readonly db: Database
   readonly queries: QueryLog
-  /**
-   * The engine underneath, for the few tests that need to send it something
-   * drizzle cannot: `exec()` takes a script of several statements, which is how
-   * the migration files arrive and what a prepared statement refuses.
-   */
   readonly client: PGlite
   close(): Promise<void>
 }
 
-/** The checked-in migrations, as one script `client.exec()` will accept. */
 export function migrationScript(): string {
   return migrationSql().split('--> statement-breakpoint').join('\n')
 }

package/src/plugin-purge-repo.ts

@@ -32,14 +32,6 @@ export async function pluginOwnedTables(
   return rows.map((row) => String(row.table_name))
 }
 
-/**
- * Everything a plugin left behind, taken away in one transaction.
- *
- * The tables are found by prefix rather than from the plugin's own migration
- * list, because the list says what it meant to create and the schema says what
- * it did. The prefix is safe to trust: `definePlugin` refuses a migration that
- * names anything outside it, so nothing the board owns can match.
- */
 export async function purgePlugin(db: Database, pluginKey: string): Promise<PluginPurgeResult> {
   const tables = await pluginOwnedTables(db, pluginKey)
 

package/src/presence-repo.ts

@@ -118,18 +118,6 @@ export class PostgresPresenceRepository {
     }
   }
 
-  /**
-   * Records that an anonymous reader is here, under a session row with no user.
-   *
-   * The read side has counted these rows since presence was written — the
-   * `user_id` column is nullable for exactly this — but nothing ever wrote one,
-   * so every board reported zero guests forever. This is the missing half.
-   *
-   * `windowSeconds` throttles the write the way the member path does: a reader
-   * clicking through a thread should cost one update a minute, not one an
-   * article. The insert is unconditional, though, or a reader whose first page
-   * view landed inside another reader's throttle window would never appear.
-   */
   async touchGuest(input: {
     readonly tokenHash: string
     readonly location: {
@@ -161,14 +149,6 @@ export class PostgresPresenceRepository {
     `)
   }
 
-  /**
-   * Forgets a guest row, for when the reader holding it has just signed in.
-   *
-   * Without this they are two people for the next fifteen minutes — a member in
-   * the list and a guest in the count — because the row they browsed under is
-   * still inside the window and there is nothing tying it to the account they
-   * have now proved they own.
-   */
   async dropGuest(tokenHash: string): Promise<void> {
     await this.db.execute(sql`
       delete from sessions where token_hash = ${tokenHash} and user_id is null

package/src/schema/identity.ts

@@ -110,6 +110,7 @@ export const users = pgTable(
 
     lastActiveAt: timestamp('last_active_at', { withTimezone: true }),
     emailVerifiedAt: timestamp('email_verified_at', { withTimezone: true }),
+    massMailOptInAt: timestamp('mass_mail_opt_in_at', { withTimezone: true }),
 
     suspendedPostingUntil: timestamp('suspended_posting_until', { withTimezone: true }),
     moderatedPostingUntil: timestamp('moderated_posting_until', { withTimezone: true }),
@@ -141,6 +142,7 @@ export const users = pgTable(
     index('users_signature_render_version_idx')
       .on(t.signatureRenderVersion, t.id)
       .where(sql`${t.signature} <> ''`),
+    index('users_mass_mail_opt_in_idx').on(t.id).where(sql`${t.massMailOptInAt} is not null`),
   ],
 )
 

package/src/schema/platform.ts

@@ -160,27 +160,11 @@ export const pluginHealth = pgTable('plugin_health', {
   updatedAt: timestamp('updated_at', { withTimezone: true }).notNull().defaultNow(),
 })
 
-/**
- * The cached copy of the meith.dev marketplace feed (or a self-hosted
- * mirror's) — a single row, refreshed daily by a task and on demand by the
- * admin panel's "Refresh" button. `feed` and `fetchedAt` are null until the
- * first successful fetch; `error`/`errorAt` describe the most recent failed
- * attempt, cleared on the next success, so a board with no outbound network
- * shows a plain "unreachable" note rather than nothing. `notifiedUpdates`
- * carries `"<plugin key>@<version>"` strings, one per update notification
- * ever sent, which is what makes that notification fire once per version —
- * not once per unread bell entry, which the notification service's own
- * dedupe key gives up on as soon as the entry is read.
- */
 export const marketplaceCatalog = pgTable(
   'marketplace_catalog',
   {
     id: smallint('id').primaryKey().default(1),
     feed: jsonb('feed'),
-    /** The feed URL the cached copy was actually fetched from — screenshots are
-     *  absolute *paths*, resolved against this rather than against whatever the
-     *  setting reads today, so a mid-day setting change cannot point an old
-     *  cached screenshot at the wrong host. */
     sourceUrl: text('source_url'),
     fetchedAt: timestamp('fetched_at', { withTimezone: true }),
     error: text('error'),

package/src/user-admin-repo.ts

@@ -54,7 +54,6 @@ export interface UserSearchRow {
 export interface UserSearchPage {
   readonly rows: readonly UserSearchRow[]
   readonly nextCursor: number | null
-  /** How many accounts the filter matches, whichever page was asked for. */
   readonly total: number
 }
 

package/src/user-bulk-repo.ts

@@ -296,6 +296,16 @@ export class PostgresUserBulkRepository {
     }
   }
 
+  async mayReceiveMassMail(userId: number): Promise<boolean> {
+    const rows = resultRows(
+      await this.db.execute(sql`
+        select 1 as ok from users u
+         where u.id = ${userId} and ${this.audienceWhere(null)}
+      `),
+    ) as Array<{ ok: number }>
+    return rows.length > 0
+  }
+
   async massMailAudience(targetGroupId: number | null): Promise<number> {
     const rows = resultRows(
       await this.db.execute(sql`
@@ -332,6 +342,7 @@ export class PostgresUserBulkRepository {
       sql`u.deleted_at is null`,
       sql`u.state = 'active'`,
       sql`u.email_verified_at is not null`,
+      sql`u.mass_mail_opt_in_at is not null`,
     ]
 
     if (targetGroupId !== null) {