create-windy 0.2.33 → 0.3.0

package/template/apps/server/src/notification/drizzle-repository.integration.test.ts

@@ -0,0 +1,301 @@
+import { afterAll, beforeAll, describe, expect, test } from "bun:test";
+import { resolve } from "node:path";
+import { drizzle } from "drizzle-orm/node-postgres";
+import { migrate } from "drizzle-orm/node-postgres/migrator";
+import type { NodePgDatabase } from "drizzle-orm/node-postgres";
+import { Pool } from "pg";
+import type { RequestActor } from "../guards.js";
+import { buildActorScopeContexts } from "../data-access/context.js";
+import { DrizzleNotificationDeliveryRepository } from "./delivery-repository.js";
+import { DrizzleNotificationPreferenceRepository } from "./preference-repository.js";
+import { DrizzleNotificationRepository } from "./drizzle-repository.js";
+
+const databaseUrl = process.env.NOTIFICATION_TEST_DATABASE_URL;
+const describePostgres = databaseUrl ? describe : describe.skip;
+
+describePostgres("PostgreSQL 通知 Repository", () => {
+  let pool: Pool;
+  let db: NodePgDatabase;
+  let repository: DrizzleNotificationRepository;
+  let rootDepartmentId: string;
+
+  beforeAll(async () => {
+    pool = new Pool({ connectionString: databaseUrl });
+    db = drizzle(pool);
+    await migrate(db, {
+      migrationsFolder: resolve(
+        import.meta.dir,
+        "../../../../packages/database/drizzle",
+      ),
+      migrationsSchema: "public",
+      migrationsTable: "__notification_test_migrations",
+    });
+    await pool.query(
+      "truncate table notification_delivery_outbox, notification_preferences, notification_favorites, notification_reads, notification_revisions, platform_notifications",
+    );
+    await pool.query(`insert into users (
+      id, username, display_name, status, created_by, updated_by
+    ) values
+      ('notification-user-a', 'notification-user-a', '通知用户 A', 'active', 'test', 'test'),
+      ('notification-user-b', 'notification-user-b', '通知用户 B', 'active', 'test', 'test')
+    on conflict (id) do nothing`);
+    const root = await pool.query<{ id: string }>(
+      "select id from departments where parent_id is null and deleted_at is null limit 1",
+    );
+    rootDepartmentId = root.rows[0]?.id || "notification-root";
+    if (root.rows.length === 0) {
+      await pool.query(
+        `insert into departments
+          (id, name, code, "order", status, created_by, updated_by)
+         values ($1, '通知测试根部门', 'NOTIFICATION_ROOT', 1, 'active', 'test', 'test')`,
+        [rootDepartmentId],
+      );
+    }
+    await pool.query(
+      `insert into departments
+        (id, parent_id, name, code, "order", status, created_by, updated_by)
+       values
+        ('notification-child', $1, '通知测试子部门', 'NOTIFICATION_CHILD', 1, 'active', 'test', 'test')
+       on conflict (id) do update set parent_id = excluded.parent_id`,
+      [rootDepartmentId],
+    );
+    await pool.query(
+      "update users set department_id = 'notification-child' where id = 'notification-user-a'",
+    );
+    repository = new DrizzleNotificationRepository(db);
+  });
+
+  afterAll(async () => {
+    await pool?.end();
+  });
+
+  test("组合筛选与 total 使用同一 Actor 可见范围", async () => {
+    await repository.publish(notice("季度安全提醒", "安全"), admin);
+    const selected = await repository.publish(
+      notice("安全维护窗口", "安全"),
+      admin,
+    );
+    await repository.publish(notice("产品更新", "产品"), admin);
+    await repository.publish(
+      {
+        ...notice("其他用户维护通知", "安全"),
+        recipientUserId: userB.id,
+      },
+      admin,
+    );
+    await repository.markRead(selected.id, userA);
+    await repository.setFavorite(selected.id, true, userA);
+
+    const result = await repository.listInbox(userA, 1, 1, {
+      q: "维护",
+      category: "安全",
+      read: "read",
+      favorite: true,
+    });
+
+    expect(result).toMatchObject({ total: 1, page: 1, pageSize: 1 });
+    expect(result.items[0]).toMatchObject({
+      id: selected.id,
+      read: true,
+      favorite: true,
+    });
+  });
+
+  test("收藏跨 Repository 持久化、按 Actor 隔离且不改变已读", async () => {
+    const published = await repository.publish(
+      notice("持久化收藏测试", "系统"),
+      admin,
+    );
+    const favorites = await Promise.all([
+      repository.setFavorite(published.id, true, userA),
+      repository.setFavorite(published.id, true, userA),
+    ]);
+    expect(favorites.filter((result) => result?.changed)).toHaveLength(1);
+
+    const restarted = new DrizzleNotificationRepository(drizzle(pool));
+    expect((await restarted.listInbox(userA, 1, 10)).items).toContainEqual(
+      expect.objectContaining({
+        id: published.id,
+        favorite: true,
+        read: false,
+      }),
+    );
+    expect((await restarted.listInbox(userB, 1, 10)).items).toContainEqual(
+      expect.objectContaining({
+        id: published.id,
+        favorite: false,
+        read: false,
+      }),
+    );
+
+    await restarted.markRead(published.id, userA);
+    const removals = await Promise.all([
+      restarted.setFavorite(published.id, false, userA),
+      restarted.setFavorite(published.id, false, userA),
+    ]);
+    expect(removals.filter((result) => result?.changed)).toHaveLength(1);
+    expect((await restarted.listInbox(userA, 1, 10)).items).toContainEqual(
+      expect.objectContaining({
+        id: published.id,
+        favorite: false,
+        read: true,
+      }),
+    );
+  });
+
+  test("不可见通知的收藏和取消收藏统一拒绝", async () => {
+    const targeted = await repository.publish(
+      {
+        ...notice("仅用户 A 可见", "审批"),
+        recipientUserId: userA.id,
+      },
+      admin,
+    );
+
+    expect(
+      await repository.setFavorite(targeted.id, true, userB),
+    ).toBeUndefined();
+    expect(
+      await repository.setFavorite(targeted.id, false, userB),
+    ).toBeUndefined();
+  });
+
+  test("并发修改串行生成版本号并由重建 Repository 查询时间历史", async () => {
+    const published = await repository.publish(
+      notice("版本历史公告", "系统"),
+      admin,
+    );
+    const results = await Promise.all([
+      repository.update(published.id, notice("版本历史公告 A", "安全"), userA),
+      repository.update(published.id, notice("版本历史公告 B", "产品"), userB),
+    ]);
+    expect(results.every((result) => result?.changed)).toBe(true);
+    expect(
+      results.map((result) => result?.notification.revision).sort(),
+    ).toEqual([2, 3]);
+
+    const restarted = new DrizzleNotificationRepository(drizzle(pool));
+    const history = await restarted.listRevisions(published.id, 1, 10);
+    expect(history?.total).toBe(3);
+    expect(history?.items.map(({ revision }) => revision)).toEqual([3, 2, 1]);
+    expect(
+      history?.items.every(
+        ({ editedAt, editedBy }) => Boolean(editedAt) && Boolean(editedBy),
+      ),
+    ).toBe(true);
+  });
+
+  test("归档公告拒绝修改但保留版本历史", async () => {
+    const published = await repository.publish(
+      notice("归档历史公告", "系统"),
+      admin,
+    );
+    await repository.archive(published.id, admin);
+
+    expect(
+      await repository.update(
+        published.id,
+        notice("归档后修改", "系统"),
+        admin,
+      ),
+    ).toBeUndefined();
+    expect((await repository.listRevisions(published.id, 1, 10))?.total).toBe(
+      1,
+    );
+  });
+
+  test("父部门通知包含子部门用户，其他用户不可见", async () => {
+    const targeted = await repository.publish(
+      {
+        ...notice("部门定向通知", "组织"),
+        recipientDepartmentIds: [rootDepartmentId],
+        includeChildDepartments: true,
+      },
+      admin,
+    );
+    const scopedUserA = actor(
+      "notification-user-a",
+      ["member"],
+      "notification-child",
+    );
+    expect(
+      (await repository.listInbox(scopedUserA, 1, 100)).items,
+    ).toContainEqual(expect.objectContaining({ id: targeted.id }));
+    expect(
+      (await repository.listInbox(userB, 1, 100)).items,
+    ).not.toContainEqual(expect.objectContaining({ id: targeted.id }));
+  });
+
+  test("偏好与 outbox 跨 Repository 持久化，lease token 防止伪完成", async () => {
+    const preferences = new DrizzleNotificationPreferenceRepository(db);
+    expect(
+      await preferences.save(
+        userA.id,
+        { enabledChannels: ["email"], disabledCategories: ["营销"] },
+        userA.id,
+      ),
+    ).toMatchObject({
+      enabledChannels: ["email"],
+      disabledCategories: ["营销"],
+    });
+    expect(
+      await new DrizzleNotificationPreferenceRepository(db).get(userA.id),
+    ).toMatchObject({ enabledChannels: ["email"] });
+
+    const published = await repository.publish(
+      notice("外部投递通知", "系统"),
+      admin,
+    );
+    const deliveries = new DrizzleNotificationDeliveryRepository(db);
+    expect(
+      await deliveries.enqueue([
+        {
+          notificationId: published.id,
+          userId: userA.id,
+          channel: "email",
+          subject: published.title,
+          content: published.content,
+        },
+      ]),
+    ).toBe(1);
+    const [claimed] = await deliveries.claim(new Date(), 10);
+    expect(claimed).toBeDefined();
+    expect(await deliveries.complete(claimed!.id, "forged-token")).toBe(false);
+    expect(
+      await deliveries.complete(claimed!.id, claimed!.leaseToken, "smtp-1"),
+    ).toBe(true);
+    expect((await deliveries.list(published.id))[0]).toMatchObject({
+      status: "delivered",
+      attemptCount: 1,
+    });
+  });
+});
+
+function notice(title: string, category: string) {
+  return {
+    title,
+    summary: `${title}摘要`,
+    content: `${title}正文`,
+    category,
+  };
+}
+
+const admin = actor("notification-admin", ["admin"]);
+const userA = actor("notification-user-a", ["member"]);
+const userB = actor("notification-user-b", ["member"]);
+
+function actor(
+  id: string,
+  roleCodes: string[],
+  departmentId?: string,
+): RequestActor {
+  const scopes = buildActorScopeContexts(id, departmentId, []);
+  return {
+    id,
+    name: id,
+    type: "user",
+    roleCodes,
+    permissionKeys: ["system.notification.read"],
+    ...scopes,
+  };
+}

package/template/apps/server/src/notification/drizzle-repository.ts

@@ -1,31 +1,48 @@
-import { notificationReads, platformNotifications } from "@southwind-ai/database";
+import {
+  notificationFavorites,
+  notificationReads,
+  platformNotifications,
+} from "@southwind-ai/database";
 import type {
+  NotificationInboxFilters,
   NotificationInboxItem,
   PageResult,
   PlatformNotification,
   PublishNotificationInput,
+  UpdateNotificationInput,
 } from "@southwind-ai/shared";
-import { and, desc, eq, ilike, isNull, or, sql, type SQL } from "drizzle-orm";
+import { and, desc, eq, sql } from "drizzle-orm";
 import type { NodePgDatabase } from "drizzle-orm/node-postgres";
 import type { RequestActor } from "../guards.js";
+import {
+  audienceWhere,
+  inboxWhere,
+  searchWhere,
+  toNotification,
+} from "./drizzle-query.js";
+import {
+  archiveNotification,
+  listNotificationRevisions,
+  publishNotification,
+  updateNotification,
+} from "./drizzle-management.js";
 import type { NotificationRepository } from "./repository.js";
 
 export class DrizzleNotificationRepository implements NotificationRepository {
   constructor(private readonly db: NodePgDatabase) {}
 
   async listInbox(
-    actor: Pick<RequestActor, "id" | "roleCodes">,
+    actor: Pick<RequestActor, "id" | "roleCodes" | "scopeContext">,
     page: number,
     pageSize: number,
+    filters: NotificationInboxFilters = {},
   ) {
-    const where = and(
-      eq(platformNotifications.status, "published"),
-      audienceWhere(actor),
-    );
+    const where = inboxWhere(actor, filters);
     const rows = await this.db
       .select({
         notification: platformNotifications,
         readAt: notificationReads.readAt,
+        favoritedAt: notificationFavorites.favoritedAt,
       })
       .from(platformNotifications)
       .leftJoin(
@@ -35,6 +52,13 @@ export class DrizzleNotificationRepository implements NotificationRepository {
           eq(notificationReads.userId, actor.id),
         ),
       )
+      .leftJoin(
+        notificationFavorites,
+        and(
+          eq(notificationFavorites.notificationId, platformNotifications.id),
+          eq(notificationFavorites.userId, actor.id),
+        ),
+      )
       .where(where)
       .orderBy(desc(platformNotifications.publishedAt))
       .limit(pageSize)
@@ -42,12 +66,28 @@ export class DrizzleNotificationRepository implements NotificationRepository {
     const [{ count = 0 } = { count: 0 }] = await this.db
       .select({ count: sql<number>`count(*)::int` })
       .from(platformNotifications)
+      .leftJoin(
+        notificationReads,
+        and(
+          eq(notificationReads.notificationId, platformNotifications.id),
+          eq(notificationReads.userId, actor.id),
+        ),
+      )
+      .leftJoin(
+        notificationFavorites,
+        and(
+          eq(notificationFavorites.notificationId, platformNotifications.id),
+          eq(notificationFavorites.userId, actor.id),
+        ),
+      )
       .where(where);
     return {
-      items: rows.map(({ notification, readAt }) => ({
+      items: rows.map(({ notification, readAt, favoritedAt }) => ({
         ...toNotification(notification),
         read: Boolean(readAt),
         readAt: readAt?.toISOString(),
+        favorite: Boolean(favoritedAt),
+        favoritedAt: favoritedAt?.toISOString(),
       })),
       total: count,
       page,
@@ -85,36 +125,59 @@ export class DrizzleNotificationRepository implements NotificationRepository {
   }
 
   async publish(input: PublishNotificationInput, actor: RequestActor) {
-    const now = new Date();
+    return publishNotification(this.db, input, actor);
+  }
+
+  async listDueScheduled(now: Date, limit: number) {
+    const rows = await this.db
+      .select()
+      .from(platformNotifications)
+      .where(
+        and(
+          eq(platformNotifications.status, "scheduled"),
+          sql`${platformNotifications.scheduledFor} <= ${now}`,
+        ),
+      )
+      .orderBy(platformNotifications.scheduledFor)
+      .limit(limit);
+    return rows.map(toNotification);
+  }
+
+  async activateScheduled(notificationId: string, now: Date) {
     const [row] = await this.db
-      .insert(platformNotifications)
-      .values({
-        id: Bun.randomUUIDv7(),
-        ...input,
+      .update(platformNotifications)
+      .set({
         status: "published",
         publishedAt: now,
-        createdAt: now,
-        createdBy: actor.id,
         updatedAt: now,
-        updatedBy: actor.id,
+        updatedBy: "notification-scheduler",
       })
-      .onConflictDoNothing()
+      .where(
+        and(
+          eq(platformNotifications.id, notificationId),
+          eq(platformNotifications.status, "scheduled"),
+          sql`${platformNotifications.scheduledFor} <= ${now}`,
+        ),
+      )
       .returning();
-    if (!row && input.sourceKey) {
-      const [existing] = await this.db
-        .select()
-        .from(platformNotifications)
-        .where(eq(platformNotifications.sourceKey, input.sourceKey))
-        .limit(1);
-      if (existing) return toNotification(existing);
-    }
-    if (!row) throw new Error("通知发布未返回记录");
-    return toNotification(row);
+    return row ? toNotification(row) : undefined;
+  }
+
+  async update(
+    notificationId: string,
+    input: UpdateNotificationInput,
+    actor: RequestActor,
+  ) {
+    return updateNotification(this.db, notificationId, input, actor);
+  }
+
+  async listRevisions(notificationId: string, page: number, pageSize: number) {
+    return listNotificationRevisions(this.db, notificationId, page, pageSize);
   }
 
   async markRead(
     notificationId: string,
-    actor: Pick<RequestActor, "id" | "roleCodes">,
+    actor: Pick<RequestActor, "id" | "roleCodes" | "scopeContext">,
   ) {
     const [notification] = await this.db
       .select({ id: platformNotifications.id })
@@ -160,74 +223,77 @@ export class DrizzleNotificationRepository implements NotificationRepository {
       : undefined;
   }
 
+  async setFavorite(
+    notificationId: string,
+    favorite: boolean,
+    actor: Pick<RequestActor, "id" | "roleCodes" | "scopeContext">,
+  ) {
+    if (!(await this.isVisible(notificationId, actor))) return undefined;
+    if (!favorite) {
+      const deleted = await this.db
+        .delete(notificationFavorites)
+        .where(
+          and(
+            eq(notificationFavorites.notificationId, notificationId),
+            eq(notificationFavorites.userId, actor.id),
+          ),
+        )
+        .returning({ notificationId: notificationFavorites.notificationId });
+      return {
+        success: true,
+        favorite: false,
+        changed: Boolean(deleted[0]),
+      } as const;
+    }
+    const favoritedAt = new Date();
+    const inserted = await this.db
+      .insert(notificationFavorites)
+      .values({ notificationId, userId: actor.id, favoritedAt })
+      .onConflictDoNothing()
+      .returning({ favoritedAt: notificationFavorites.favoritedAt });
+    const persistedAt =
+      inserted[0]?.favoritedAt ||
+      (
+        await this.db
+          .select({ favoritedAt: notificationFavorites.favoritedAt })
+          .from(notificationFavorites)
+          .where(
+            and(
+              eq(notificationFavorites.notificationId, notificationId),
+              eq(notificationFavorites.userId, actor.id),
+            ),
+          )
+          .limit(1)
+      )[0]?.favoritedAt;
+    return persistedAt
+      ? ({
+          success: true,
+          favorite: true,
+          changed: Boolean(inserted[0]),
+          favoritedAt: persistedAt.toISOString(),
+        } as const)
+      : undefined;
+  }
+
   async archive(notificationId: string, actor: RequestActor) {
-    const now = new Date();
-    const [row] = await this.db
-      .update(platformNotifications)
-      .set({
-        status: "archived",
-        archivedAt: now,
-        archivedBy: actor.id,
-        updatedAt: now,
-        updatedBy: actor.id,
-      })
+    return archiveNotification(this.db, notificationId, actor);
+  }
+
+  private async isVisible(
+    notificationId: string,
+    actor: Pick<RequestActor, "id" | "roleCodes" | "scopeContext">,
+  ) {
+    const [notification] = await this.db
+      .select({ id: platformNotifications.id })
+      .from(platformNotifications)
       .where(
         and(
           eq(platformNotifications.id, notificationId),
           eq(platformNotifications.status, "published"),
+          audienceWhere(actor),
         ),
       )
-      .returning();
-    return row ? toNotification(row) : undefined;
+      .limit(1);
+    return Boolean(notification);
   }
 }
-
-function toNotification(
-  row: typeof platformNotifications.$inferSelect,
-): PlatformNotification {
-  return {
-    id: row.id,
-    title: row.title,
-    summary: row.summary,
-    content: row.content,
-    category: row.category,
-    status: row.status as PlatformNotification["status"],
-    publishedAt: row.publishedAt.toISOString(),
-    createdAt: row.createdAt.toISOString(),
-    createdBy: row.createdBy,
-    updatedAt: row.updatedAt.toISOString(),
-    updatedBy: row.updatedBy,
-    archivedAt: row.archivedAt?.toISOString(),
-    archivedBy: row.archivedBy || undefined,
-    target: row.target || undefined,
-    recipientUserId: row.recipientUserId || undefined,
-    recipientRoleCodes: row.recipientRoleCodes,
-    sourceKey: row.sourceKey || undefined,
-  };
-}
-
-function audienceWhere(actor: Pick<RequestActor, "id" | "roleCodes">): SQL {
-  const roleClauses = actor.roleCodes.map(
-    (role) =>
-      sql`${platformNotifications.recipientRoleCodes} @> ${JSON.stringify([role])}::jsonb`,
-  );
-  return or(
-    and(
-      isNull(platformNotifications.recipientUserId),
-      sql`jsonb_array_length(${platformNotifications.recipientRoleCodes}) = 0`,
-    ),
-    eq(platformNotifications.recipientUserId, actor.id),
-    ...roleClauses,
-  )!;
-}
-
-function searchWhere(query?: string): SQL | undefined {
-  const keyword = query?.trim();
-  return keyword
-    ? or(
-        ilike(platformNotifications.title, `%${keyword}%`),
-        ilike(platformNotifications.summary, `%${keyword}%`),
-        ilike(platformNotifications.category, `%${keyword}%`),
-      )
-    : undefined;
-}