create-windy 0.2.33 → 0.3.0

package/template/apps/server/src/notification/repository.test.ts

@@ -0,0 +1,171 @@
+import { describe, expect, test } from "bun:test";
+import type { PublishNotificationInput } from "@southwind-ai/shared";
+import type { RequestActor } from "../guards.js";
+import { InMemoryNotificationRepository } from "./repository.js";
+
+describe("内存通知收件箱", () => {
+  test("关键词、分类、已读和收藏组合在分页前筛选并返回正确总数", async () => {
+    const repository = new InMemoryNotificationRepository();
+    await repository.publish(notice("季度安全提醒", "安全"), admin);
+    const first = await repository.publish(
+      notice("安全维护窗口", "安全"),
+      admin,
+    );
+    await repository.publish(notice("产品更新", "产品"), admin);
+    await repository.markRead(first.id, userA);
+    await repository.setFavorite(first.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: first.id,
+      read: true,
+      favorite: true,
+    });
+  });
+
+  test("收藏按 Actor 隔离，且与已读状态相互独立", async () => {
+    const repository = new InMemoryNotificationRepository();
+    const published = await repository.publish(
+      notice("独立状态测试", "系统"),
+      admin,
+    );
+    await repository.setFavorite(published.id, true, userA);
+
+    expect((await repository.listInbox(userA, 1, 10)).items[0]).toMatchObject({
+      favorite: true,
+      read: false,
+    });
+    expect((await repository.listInbox(userB, 1, 10)).items[0]).toMatchObject({
+      favorite: false,
+      read: false,
+    });
+
+    await repository.markRead(published.id, userA);
+    await repository.setFavorite(published.id, false, userA);
+    expect((await repository.listInbox(userA, 1, 10)).items[0]).toMatchObject({
+      favorite: false,
+      read: true,
+    });
+  });
+
+  test("不可见通知不能通过猜测 ID 收藏或取消收藏", async () => {
+    const repository = new InMemoryNotificationRepository();
+    const targeted = await repository.publish(
+      {
+        ...notice("定向通知", "审批"),
+        recipientUserId: userA.id,
+      },
+      admin,
+    );
+
+    expect(
+      await repository.setFavorite(targeted.id, true, userB),
+    ).toBeUndefined();
+    expect(
+      await repository.setFavorite(targeted.id, false, userB),
+    ).toBeUndefined();
+    expect((await repository.listInbox(userB, 1, 10)).total).toBe(0);
+  });
+
+  test("快速重复收藏和取消收藏保持幂等", async () => {
+    const repository = new InMemoryNotificationRepository();
+    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);
+    expect(
+      (await repository.listInbox(userA, 1, 10, { favorite: true })).total,
+    ).toBe(1);
+
+    const removals = await Promise.all([
+      repository.setFavorite(published.id, false, userA),
+      repository.setFavorite(published.id, false, userA),
+    ]);
+    expect(removals.filter((result) => result?.changed)).toHaveLength(1);
+    expect(
+      (await repository.listInbox(userA, 1, 10, { favorite: true })).total,
+    ).toBe(0);
+  });
+
+  test("发布形成初始版本，修改追加不可变历史和时间", async () => {
+    const repository = new InMemoryNotificationRepository();
+    const published = await repository.publish(
+      notice("初始公告", "系统"),
+      admin,
+    );
+    const updated = await repository.update(
+      published.id,
+      notice("修改公告", "安全"),
+      userA,
+    );
+    const repeated = await repository.update(
+      published.id,
+      notice("修改公告", "安全"),
+      userA,
+    );
+    const history = await repository.listRevisions(published.id, 1, 10);
+
+    expect(updated).toMatchObject({
+      changed: true,
+      notification: { revision: 2, title: "修改公告" },
+    });
+    expect(repeated).toMatchObject({ changed: false });
+    expect(history?.total).toBe(2);
+    expect(history?.items).toMatchObject([
+      { revision: 2, editedBy: userA.id, editedAt: expect.any(String) },
+      { revision: 1, editedBy: admin.id, editedAt: expect.any(String) },
+    ]);
+  });
+
+  test("归档公告保持历史可读但拒绝继续修改", async () => {
+    const repository = new InMemoryNotificationRepository();
+    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,
+    );
+  });
+});
+
+function notice(title: string, category: string): PublishNotificationInput {
+  return {
+    title,
+    summary: `${title}摘要`,
+    content: `${title}正文`,
+    category,
+  };
+}
+
+const admin = actor("admin", ["admin"]);
+const userA = actor("user-a", ["member"]);
+const userB = actor("user-b", ["member"]);
+
+function actor(id: string, roleCodes: string[]): RequestActor {
+  return {
+    id,
+    name: id,
+    type: "user",
+    roleCodes,
+    permissionKeys: ["system.notification.read"],
+  };
+}

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

@@ -1,18 +1,30 @@
 import { randomUUIDv7 } from "bun";
 import type {
   MarkNotificationReadResult,
+  NotificationInboxFilters,
   NotificationInboxItem,
+  NotificationRevision,
   PageResult,
   PlatformNotification,
   PublishNotificationInput,
+  SetNotificationFavoriteResult,
+  UpdateNotificationInput,
+  UpdateNotificationResult,
 } from "@southwind-ai/shared";
 import type { RequestActor } from "../guards.js";
+import {
+  pageResult,
+  sameContent,
+  toRevision,
+  visibleTo,
+} from "./memory-support.js";
 
 export interface NotificationRepository {
   listInbox(
-    actor: Pick<RequestActor, "id" | "roleCodes">,
+    actor: Pick<RequestActor, "id" | "roleCodes" | "scopeContext">,
     page: number,
     pageSize: number,
+    filters?: NotificationInboxFilters,
   ): Promise<PageResult<NotificationInboxItem>>;
   listManaged(
     page: number,
@@ -23,10 +35,30 @@ export interface NotificationRepository {
     input: PublishNotificationInput,
     actor: RequestActor,
   ): Promise<PlatformNotification>;
+  listDueScheduled(now: Date, limit: number): Promise<PlatformNotification[]>;
+  activateScheduled(
+    notificationId: string,
+    now: Date,
+  ): Promise<PlatformNotification | undefined>;
+  update(
+    notificationId: string,
+    input: UpdateNotificationInput,
+    actor: RequestActor,
+  ): Promise<UpdateNotificationResult | undefined>;
+  listRevisions(
+    notificationId: string,
+    page: number,
+    pageSize: number,
+  ): Promise<PageResult<NotificationRevision> | undefined>;
   markRead(
     notificationId: string,
-    actor: Pick<RequestActor, "id" | "roleCodes">,
+    actor: Pick<RequestActor, "id" | "roleCodes" | "scopeContext">,
   ): Promise<MarkNotificationReadResult | undefined>;
+  setFavorite(
+    notificationId: string,
+    favorite: boolean,
+    actor: Pick<RequestActor, "id" | "roleCodes" | "scopeContext">,
+  ): Promise<SetNotificationFavoriteResult | undefined>;
   archive(
     notificationId: string,
     actor: RequestActor,
@@ -36,21 +68,49 @@ export interface NotificationRepository {
 export class InMemoryNotificationRepository implements NotificationRepository {
   private readonly notifications = new Map<string, PlatformNotification>();
   private readonly reads = new Map<string, string>();
+  private readonly favorites = new Map<string, string>();
+  private readonly revisions = new Map<string, NotificationRevision[]>();
   private readonly sources = new Map<string, string>();
 
   async listInbox(
-    actor: Pick<RequestActor, "id" | "roleCodes">,
+    actor: Pick<RequestActor, "id" | "roleCodes" | "scopeContext">,
     page: number,
     pageSize: number,
+    filters: NotificationInboxFilters = {},
   ) {
+    const keyword = filters.q?.trim().toLowerCase();
+    const category = filters.category?.trim();
     const items = [...this.notifications.values()]
       .filter(({ status }) => status === "published")
       .filter((item) => visibleTo(item, actor))
+      .filter((item) =>
+        keyword
+          ? [item.title, item.summary, item.content, item.category].some(
+              (value) => value.toLowerCase().includes(keyword),
+            )
+          : true,
+      )
+      .filter((item) => (category ? item.category === category : true))
       .sort((left, right) => right.publishedAt.localeCompare(left.publishedAt))
       .map((item) => {
         const readAt = this.reads.get(readKey(item.id, actor.id));
-        return { ...item, read: Boolean(readAt), readAt };
-      });
+        const favoritedAt = this.favorites.get(favoriteKey(item.id, actor.id));
+        return {
+          ...item,
+          read: Boolean(readAt),
+          readAt,
+          favorite: Boolean(favoritedAt),
+          favoritedAt,
+        };
+      })
+      .filter((item) =>
+        filters.read ? item.read === (filters.read === "read") : true,
+      )
+      .filter((item) =>
+        filters.favorite === undefined
+          ? true
+          : item.favorite === filters.favorite,
+      );
     return pageResult(items, page, pageSize);
   }
 
@@ -80,21 +140,92 @@ export class InMemoryNotificationRepository implements NotificationRepository {
     const notification: PlatformNotification = {
       id: randomUUIDv7(),
       ...input,
-      status: "published",
-      publishedAt: now,
+      status: input.scheduledFor ? "scheduled" : "published",
+      publishedAt: input.scheduledFor || now,
       createdAt: now,
       createdBy: actor.id,
       updatedAt: now,
       updatedBy: actor.id,
+      revision: 1,
     };
     this.notifications.set(notification.id, notification);
+    this.revisions.set(notification.id, [
+      toRevision(notification, now, actor.id),
+    ]);
     if (input.sourceKey) this.sources.set(input.sourceKey, notification.id);
     return notification;
   }
 
+  async listDueScheduled(now: Date, limit: number) {
+    return [...this.notifications.values()]
+      .filter(
+        (item) =>
+          item.status === "scheduled" &&
+          Boolean(item.scheduledFor && item.scheduledFor <= now.toISOString()),
+      )
+      .sort((left, right) =>
+        (left.scheduledFor || "").localeCompare(right.scheduledFor || ""),
+      )
+      .slice(0, limit);
+  }
+
+  async activateScheduled(notificationId: string, now: Date) {
+    const current = this.notifications.get(notificationId);
+    if (
+      !current ||
+      current.status !== "scheduled" ||
+      !current.scheduledFor ||
+      current.scheduledFor > now.toISOString()
+    ) {
+      return undefined;
+    }
+    const activated: PlatformNotification = {
+      ...current,
+      status: "published",
+      publishedAt: now.toISOString(),
+      updatedAt: now.toISOString(),
+      updatedBy: "notification-scheduler",
+    };
+    this.notifications.set(notificationId, activated);
+    return activated;
+  }
+
+  async update(
+    notificationId: string,
+    input: UpdateNotificationInput,
+    actor: RequestActor,
+  ) {
+    const current = this.notifications.get(notificationId);
+    if (!current || current.status !== "published") return undefined;
+    if (sameContent(current, input)) {
+      return { notification: current, changed: false };
+    }
+    const editedAt = new Date().toISOString();
+    const notification: PlatformNotification = {
+      ...current,
+      ...input,
+      revision: current.revision + 1,
+      updatedAt: editedAt,
+      updatedBy: actor.id,
+    };
+    this.notifications.set(notificationId, notification);
+    const history = this.revisions.get(notificationId) || [];
+    history.push(toRevision(notification, editedAt, actor.id));
+    this.revisions.set(notificationId, history);
+    return { notification, changed: true };
+  }
+
+  async listRevisions(notificationId: string, page: number, pageSize: number) {
+    if (!this.notifications.has(notificationId)) return undefined;
+    const history = [...(this.revisions.get(notificationId) || [])].sort(
+      (left, right) => right.revision - left.revision,
+    );
+    return pageResult(history, page, pageSize);
+  }
+
   async markRead(
     notificationId: string,
-    actor: Pick<RequestActor, "id" | "roleCodes">,
+    actor: Pick<RequestActor, "id" | "roleCodes" | "scopeContext">,
   ) {
     const notification = this.notifications.get(notificationId);
     if (
@@ -112,6 +243,44 @@ export class InMemoryNotificationRepository implements NotificationRepository {
     return { success: true, alreadyRead: false, readAt } as const;
   }
 
+  async setFavorite(
+    notificationId: string,
+    favorite: boolean,
+    actor: Pick<RequestActor, "id" | "roleCodes" | "scopeContext">,
+  ) {
+    const notification = this.notifications.get(notificationId);
+    if (
+      !notification ||
+      notification.status !== "published" ||
+      !visibleTo(notification, actor)
+    )
+      return undefined;
+    const key = favoriteKey(notificationId, actor.id);
+    const existing = this.favorites.get(key);
+    if (favorite) {
+      if (existing) {
+        return {
+          success: true,
+          favorite: true,
+          changed: false,
+          favoritedAt: existing,
+        } as const;
+      }
+      const favoritedAt = new Date().toISOString();
+      this.favorites.set(key, favoritedAt);
+      return {
+        success: true,
+        favorite: true,
+        changed: true,
+        favoritedAt,
+      } as const;
+    }
+    if (!existing)
+      return { success: true, favorite: false, changed: false } as const;
+    this.favorites.delete(key);
+    return { success: true, favorite: false, changed: true } as const;
+  }
+
   async archive(notificationId: string, actor: RequestActor) {
     const current = this.notifications.get(notificationId);
     if (!current || current.status === "archived") return undefined;
@@ -129,32 +298,10 @@ export class InMemoryNotificationRepository implements NotificationRepository {
   }
 }
 
-function visibleTo(
-  item: PlatformNotification,
-  actor: Pick<RequestActor, "id" | "roleCodes">,
-) {
-  const roles = item.recipientRoleCodes || [];
-  return (
-    (!item.recipientUserId && !roles.length) ||
-    item.recipientUserId === actor.id ||
-    roles.some((role) => actor.roleCodes.includes(role))
-  );
-}
-
 function readKey(notificationId: string, userId: string) {
   return `${notificationId}:${userId}`;
 }
 
-function pageResult<T>(
-  items: T[],
-  page: number,
-  pageSize: number,
-): PageResult<T> {
-  const start = (page - 1) * pageSize;
-  return {
-    items: items.slice(start, start + pageSize),
-    total: items.length,
-    page,
-    pageSize,
-  };
+function favoriteKey(notificationId: string, userId: string) {
+  return `${notificationId}:${userId}`;
 }

package/template/apps/server/src/notification/revision-routes.test.ts

@@ -0,0 +1,186 @@
+import { describe, expect, test } from "bun:test";
+import { createFoundationSnapshot } from "../foundation.js";
+import { createServerRuntime } from "../runtime.js";
+import { InMemoryNotificationRepository } from "./repository.js";
+import { registerNotificationRoutes } from "./routes.js";
+
+class FakeRouteApp {
+  readonly handlers = new Map<string, (context: unknown) => unknown>();
+
+  get(path: string, handler: (context: unknown) => unknown) {
+    this.handlers.set(`GET ${path}`, handler);
+  }
+
+  post(path: string, handler: (context: unknown) => unknown) {
+    this.handlers.set(`POST ${path}`, handler);
+  }
+
+  put(path: string, handler: (context: unknown) => unknown) {
+    this.handlers.set(`PUT ${path}`, handler);
+  }
+
+  delete(path: string, handler: (context: unknown) => unknown) {
+    this.handlers.set(`DELETE ${path}`, handler);
+  }
+
+  invoke(method: string, path: string, context: unknown) {
+    const handler = this.handlers.get(`${method} ${path}`);
+    if (!handler) throw new Error(`未注册路由 ${method} ${path}`);
+    return handler(context);
+  }
+}
+
+describe("公告修改与历史 API", () => {
+  test("管理员修改公告并分页查看版本、修改人和时间", async () => {
+    const runtime = createServerRuntime({ WINDY_DEV_ADMIN_TOKEN: "token_1" });
+    const app = new FakeRouteApp();
+    registerNotificationRoutes(
+      app,
+      new InMemoryNotificationRepository(),
+      runtime,
+      createFoundationSnapshot().features,
+    );
+    const guardContext = await runtime.createGuardContext(
+      new Request("http://localhost/api/system/notifications", {
+        headers: { authorization: "Bearer token_1" },
+      }),
+    );
+    const published = (await app.invoke("POST", "/system/notifications", {
+      guardContext,
+      params: {},
+      query: {},
+      body: notice("初始公告"),
+    })) as { id: string; revision: number };
+
+    const updated = await app.invoke("PUT", "/system/notifications/:id", {
+      guardContext,
+      params: { id: published.id },
+      query: {},
+      body: notice("修改公告"),
+    });
+    const repeated = await app.invoke("PUT", "/system/notifications/:id", {
+      guardContext,
+      params: { id: published.id },
+      query: {},
+      body: notice("修改公告"),
+    });
+    const history = (await app.invoke(
+      "GET",
+      "/system/notifications/:id/revisions",
+      {
+        guardContext,
+        params: { id: published.id },
+        query: { page: "1", pageSize: "1" },
+      },
+    )) as {
+      total: number;
+      items: Array<{ revision: number; editedAt: string; editedBy: string }>;
+    };
+
+    expect(published.revision).toBe(1);
+    expect(updated).toMatchObject({
+      changed: true,
+      notification: { revision: 2, title: "修改公告" },
+    });
+    expect(repeated).toMatchObject({ changed: false });
+    expect(history.total).toBe(2);
+    expect(history.items[0]).toMatchObject({
+      revision: 2,
+      editedAt: expect.any(String),
+      editedBy: expect.any(String),
+    });
+    expect(runtime.auditSink.list().map(({ action }) => action)).toEqual([
+      "notification.publish",
+      "notification.update",
+    ]);
+  });
+
+  test("修改与历史分别要求 update 和 manage 权限，非法内容被拒绝", async () => {
+    const runtime = createServerRuntime();
+    const repository = new InMemoryNotificationRepository();
+    const app = new FakeRouteApp();
+    registerNotificationRoutes(
+      app,
+      repository,
+      runtime,
+      createFoundationSnapshot().features,
+    );
+    const actor = {
+      id: "reader",
+      type: "user" as const,
+      name: "普通用户",
+      roleCodes: ["member"],
+      permissionKeys: ["system.notification.read"],
+    };
+    const guardContext = await runtime.createGuardContextForActor(
+      new Request("http://localhost/api/system/notifications"),
+      actor,
+    );
+    const published = await repository.publish(notice("受保护公告"), {
+      ...actor,
+      id: "publisher",
+    });
+
+    for (const [method, path] of [
+      ["PUT", "/system/notifications/:id"],
+      ["GET", "/system/notifications/:id/revisions"],
+    ]) {
+      const response = (await app.invoke(method!, path!, {
+        guardContext,
+        params: { id: published.id },
+        query: {},
+        body: notice("越权修改"),
+      })) as Response;
+      expect(response.status).toBe(403);
+    }
+
+    const manageContext = {
+      ...guardContext,
+      actor: {
+        ...actor,
+        permissionKeys: ["system.notification.manage"],
+      },
+    };
+    const managedHistory = await app.invoke(
+      "GET",
+      "/system/notifications/:id/revisions",
+      {
+        guardContext: manageContext,
+        params: { id: published.id },
+        query: {},
+      },
+    );
+    expect(managedHistory).toMatchObject({ total: 1 });
+    const manageUpdate = (await app.invoke("PUT", "/system/notifications/:id", {
+      guardContext: manageContext,
+      params: { id: published.id },
+      query: {},
+      body: notice("无修改权限"),
+    })) as Response;
+    expect(manageUpdate.status).toBe(403);
+
+    const updateContext = {
+      ...guardContext,
+      actor: {
+        ...actor,
+        permissionKeys: ["system.notification.update"],
+      },
+    };
+    const invalid = (await app.invoke("PUT", "/system/notifications/:id", {
+      guardContext: updateContext,
+      params: { id: published.id },
+      query: {},
+      body: { ...notice(""), title: "" },
+    })) as Response;
+    expect(invalid.status).toBe(400);
+  });
+});
+
+function notice(title: string) {
+  return {
+    title,
+    summary: `${title}摘要`,
+    content: `${title}正文`,
+    category: "系统",
+  };
+}