create-windy 0.2.34 → 0.3.0

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: "系统",
+  };
+}

package/template/apps/server/src/notification/route-support.ts

@@ -0,0 +1,225 @@
+import { randomUUIDv7 } from "bun";
+import type {
+  AuditActionType,
+  NotificationInboxFilters,
+  UpdateNotificationPreferenceInput,
+  PublishNotificationInput,
+  UpdateNotificationInput,
+} from "@southwind-ai/shared";
+import { auditActor, type RequestGuardContext } from "../guards.js";
+
+export type NotificationRouteContext = {
+  body?: unknown;
+  guardContext: RequestGuardContext;
+  params: Record<string, string | undefined>;
+  query: Record<string, string | undefined>;
+};
+
+export function parsePublishInput(
+  body: unknown,
+): PublishNotificationInput | Response {
+  const content = parseContentInput(body);
+  if (content instanceof Response) return content;
+  const value = body as Record<string, unknown>;
+  const scheduledFor = optionalText(value.scheduledFor);
+  if (scheduledFor && !validFutureDate(scheduledFor)) {
+    return invalidNotification("scheduledFor 必须是未来的 ISO 时间");
+  }
+  const recipientUserIds = stringArray(value.recipientUserIds);
+  const recipientRoleCodes = stringArray(value.recipientRoleCodes);
+  const recipientDepartmentIds = stringArray(value.recipientDepartmentIds);
+  const deliveryChannels = stringArray(value.deliveryChannels);
+  if (
+    recipientUserIds instanceof Response ||
+    recipientRoleCodes instanceof Response ||
+    recipientDepartmentIds instanceof Response ||
+    deliveryChannels instanceof Response
+  ) {
+    return invalidNotification("通知受众与渠道必须是字符串数组");
+  }
+  if (
+    deliveryChannels.some((channel) => channel !== "email" && channel !== "sms")
+  ) {
+    return invalidNotification("deliveryChannels 仅支持 email 或 sms");
+  }
+  if (
+    [recipientUserIds, recipientRoleCodes, recipientDepartmentIds].some(
+      (values) => values.length > 100,
+    )
+  ) {
+    return invalidNotification("单次发布的每类受众最多 100 项");
+  }
+  return {
+    ...content,
+    scheduledFor,
+    recipientUserIds,
+    recipientRoleCodes,
+    recipientDepartmentIds,
+    includeChildDepartments: value.includeChildDepartments === true,
+    deliveryChannels: deliveryChannels.filter(
+      (channel): channel is "email" | "sms" =>
+        channel === "email" || channel === "sms",
+    ),
+  };
+}
+
+export function parseUpdateInput(
+  body: unknown,
+): UpdateNotificationInput | Response {
+  return parseContentInput(body);
+}
+
+export function parsePreferenceInput(
+  body: unknown,
+): UpdateNotificationPreferenceInput | Response {
+  const value =
+    body && typeof body === "object" ? (body as Record<string, unknown>) : {};
+  const enabledChannels = stringArray(value.enabledChannels);
+  const disabledCategories = stringArray(value.disabledCategories);
+  if (
+    enabledChannels instanceof Response ||
+    disabledCategories instanceof Response
+  ) {
+    return invalidNotification("通知偏好必须是字符串数组");
+  }
+  if (
+    enabledChannels.some(
+      (channel) => channel !== "email" && channel !== "sms",
+    ) ||
+    disabledCategories.length > 100 ||
+    disabledCategories.some((category) => category.length > 40)
+  ) {
+    return invalidNotification("通知偏好包含不支持的渠道或分类");
+  }
+  return {
+    enabledChannels: enabledChannels.filter(
+      (channel): channel is "email" | "sms" =>
+        channel === "email" || channel === "sms",
+    ),
+    disabledCategories,
+  };
+}
+
+export function parseInboxFilters(
+  query: Record<string, string | undefined>,
+): NotificationInboxFilters | Response {
+  const q = query.q?.trim();
+  const category = query.category?.trim();
+  if (q && q.length > 200) return invalidFilter("q 最多 200 个字符");
+  if (category && category.length > 40)
+    return invalidFilter("category 最多 40 个字符");
+  if (query.read && query.read !== "read" && query.read !== "unread") {
+    return invalidFilter("read 仅支持 read 或 unread");
+  }
+  if (
+    query.favorite !== undefined &&
+    query.favorite !== "" &&
+    query.favorite !== "true" &&
+    query.favorite !== "false"
+  ) {
+    return invalidFilter("favorite 仅支持 true 或 false");
+  }
+  return {
+    q: q || undefined,
+    category: category || undefined,
+    read:
+      query.read === "read" || query.read === "unread" ? query.read : undefined,
+    favorite:
+      query.favorite === "true"
+        ? true
+        : query.favorite === "false"
+          ? false
+          : undefined,
+  };
+}
+
+export function notificationEvent(
+  context: NotificationRouteContext,
+  action: AuditActionType,
+  id: string,
+) {
+  return {
+    id: randomUUIDv7(),
+    action,
+    outcome: "success" as const,
+    actor: auditActor(context.guardContext),
+    target: { type: "notification", id },
+    requestId: context.guardContext.requestId,
+    occurredAt: new Date().toISOString(),
+  };
+}
+
+export function notificationNotFound(id: string) {
+  return Response.json(
+    { error: "NOT_FOUND", resource: "notification", id },
+    { status: 404 },
+  );
+}
+
+function parseContentInput(body: unknown): UpdateNotificationInput | Response {
+  const value =
+    body && typeof body === "object" ? (body as Record<string, unknown>) : {};
+  const input = {
+    title: text(value.title),
+    summary: text(value.summary),
+    content: text(value.content),
+    category: text(value.category),
+  };
+  if (!input.title || !input.summary || !input.content || !input.category) {
+    return Response.json(
+      {
+        error: "INVALID_NOTIFICATION",
+        message: "标题、摘要、正文和分类均不能为空",
+      },
+      { status: 400 },
+    );
+  }
+  if (
+    input.title.length > 120 ||
+    input.summary.length > 240 ||
+    input.content.length > 10_000 ||
+    input.category.length > 40
+  ) {
+    return Response.json(
+      { error: "INVALID_NOTIFICATION", message: "通知内容超过长度限制" },
+      { status: 400 },
+    );
+  }
+  return input;
+}
+
+function invalidFilter(message: string) {
+  return Response.json(
+    { error: "INVALID_NOTIFICATION_FILTER", message },
+    { status: 400 },
+  );
+}
+
+function invalidNotification(message: string) {
+  return Response.json(
+    { error: "INVALID_NOTIFICATION", message },
+    { status: 400 },
+  );
+}
+
+function text(value: unknown) {
+  return typeof value === "string" ? value.trim() : "";
+}
+
+function optionalText(value: unknown) {
+  const result = text(value);
+  return result || undefined;
+}
+
+function stringArray(value: unknown): string[] | Response {
+  if (value === undefined) return [];
+  if (!Array.isArray(value) || value.some((item) => typeof item !== "string")) {
+    return invalidNotification("字段必须是字符串数组");
+  }
+  return [...new Set(value.map((item) => item.trim()).filter(Boolean))];
+}
+
+function validFutureDate(value: string) {
+  const timestamp = Date.parse(value);
+  return Number.isFinite(timestamp) && timestamp > Date.now();
+}