create-windy 0.2.34 → 0.3.0

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

@@ -0,0 +1,72 @@
+import type {
+  NotificationRevision,
+  PageResult,
+  PlatformNotification,
+  UpdateNotificationInput,
+} from "@southwind-ai/shared";
+import type { RequestActor } from "../guards.js";
+
+export function visibleTo(
+  item: PlatformNotification,
+  actor: Pick<RequestActor, "id" | "roleCodes" | "scopeContext">,
+) {
+  const roles = item.recipientRoleCodes || [];
+  const userIds = item.recipientUserIds || [];
+  const departmentIds = item.recipientDepartmentIds || [];
+  return (
+    (!item.recipientUserId &&
+      !userIds.length &&
+      !roles.length &&
+      !departmentIds.length) ||
+    item.recipientUserId === actor.id ||
+    userIds.includes(actor.id) ||
+    Boolean(
+      actor.scopeContext?.departmentId &&
+      departmentIds.includes(actor.scopeContext.departmentId),
+    ) ||
+    roles.some((role) => actor.roleCodes.includes(role))
+  );
+}
+
+export function sameContent(
+  notification: PlatformNotification,
+  input: UpdateNotificationInput,
+) {
+  return (
+    notification.title === input.title &&
+    notification.summary === input.summary &&
+    notification.content === input.content &&
+    notification.category === input.category
+  );
+}
+
+export function toRevision(
+  notification: PlatformNotification,
+  editedAt: string,
+  editedBy: string,
+): NotificationRevision {
+  return {
+    notificationId: notification.id,
+    revision: notification.revision,
+    title: notification.title,
+    summary: notification.summary,
+    content: notification.content,
+    category: notification.category,
+    editedAt,
+    editedBy,
+  };
+}
+
+export 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,
+  };
+}

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

@@ -0,0 +1,95 @@
+import { notificationPreferences } from "@southwind-ai/database";
+import type {
+  NotificationPreference,
+  UpdateNotificationPreferenceInput,
+} from "@southwind-ai/shared";
+import { eq } from "drizzle-orm";
+import type { NodePgDatabase } from "drizzle-orm/node-postgres";
+
+export interface NotificationPreferenceRepository {
+  get(userId: string): Promise<NotificationPreference | undefined>;
+  save(
+    userId: string,
+    input: UpdateNotificationPreferenceInput,
+    actorId: string,
+  ): Promise<NotificationPreference>;
+}
+
+export class InMemoryNotificationPreferenceRepository implements NotificationPreferenceRepository {
+  private readonly preferences = new Map<string, NotificationPreference>();
+
+  async get(userId: string) {
+    return this.preferences.get(userId);
+  }
+
+  async save(
+    userId: string,
+    input: UpdateNotificationPreferenceInput,
+    actorId: string,
+  ) {
+    const preference = {
+      userId,
+      enabledChannels: unique(input.enabledChannels),
+      disabledCategories: unique(input.disabledCategories),
+      updatedAt: new Date().toISOString(),
+    };
+    this.preferences.set(userId, preference);
+    void actorId;
+    return preference;
+  }
+}
+
+export class DrizzleNotificationPreferenceRepository implements NotificationPreferenceRepository {
+  constructor(private readonly db: NodePgDatabase) {}
+
+  async get(userId: string) {
+    const [row] = await this.db
+      .select()
+      .from(notificationPreferences)
+      .where(eq(notificationPreferences.userId, userId))
+      .limit(1);
+    return row ? toPreference(row) : undefined;
+  }
+
+  async save(
+    userId: string,
+    input: UpdateNotificationPreferenceInput,
+    actorId: string,
+  ) {
+    const now = new Date();
+    const [row] = await this.db
+      .insert(notificationPreferences)
+      .values({
+        userId,
+        enabledChannels: unique(input.enabledChannels),
+        disabledCategories: unique(input.disabledCategories),
+        updatedAt: now,
+        updatedBy: actorId,
+      })
+      .onConflictDoUpdate({
+        target: notificationPreferences.userId,
+        set: {
+          enabledChannels: unique(input.enabledChannels),
+          disabledCategories: unique(input.disabledCategories),
+          updatedAt: now,
+          updatedBy: actorId,
+        },
+      })
+      .returning();
+    if (!row) throw new Error("通知偏好保存未返回记录");
+    return toPreference(row);
+  }
+}
+
+function toPreference(row: typeof notificationPreferences.$inferSelect) {
+  return {
+    userId: row.userId,
+    enabledChannels: row.enabledChannels,
+    disabledCategories: row.disabledCategories,
+    updatedAt: row.updatedAt.toISOString(),
+  };
+}
+
+function unique<T>(values: T[]) {
+  return [...new Set(values)];
+}

package/template/apps/server/src/notification/recipient-directory.ts

@@ -0,0 +1,104 @@
+import type {
+  ExternalNotificationChannel,
+  NotificationAudienceOptions,
+  PublishNotificationInput,
+} from "@southwind-ai/shared";
+import type { SystemRepositories } from "../system/seed.js";
+
+export interface NotificationRecipient {
+  id: string;
+  email?: string;
+  phone?: string;
+}
+
+export interface NotificationRecipientDirectory {
+  options(): Promise<NotificationAudienceOptions>;
+  resolve(input: PublishNotificationInput): Promise<NotificationRecipient[]>;
+  address(
+    userId: string,
+    channel: ExternalNotificationChannel,
+  ): Promise<string | undefined>;
+}
+
+export class SystemNotificationRecipientDirectory implements NotificationRecipientDirectory {
+  constructor(private readonly repositories: SystemRepositories) {}
+
+  async options(): Promise<NotificationAudienceOptions> {
+    const [users, roles, departments] = await Promise.all([
+      this.repositories.users.all({ status: "active" }),
+      this.repositories.roles.all({ status: "active" }),
+      this.repositories.departments.all({ status: "active" }),
+    ]);
+    return {
+      users: users.map((user) => ({ id: user.id, label: user.displayName })),
+      roles: roles.map((role) => ({
+        id: role.id,
+        label: role.name,
+        code: role.code,
+      })),
+      departments: departments.map((department) => ({
+        id: department.id,
+        label: department.name,
+        code: department.code,
+      })),
+    };
+  }
+
+  async resolve(input: PublishNotificationInput) {
+    const [users, roles, departments] = await Promise.all([
+      this.repositories.users.all({ status: "active" }),
+      this.repositories.roles.all({ status: "active" }),
+      this.repositories.departments.all({ status: "active" }),
+    ]);
+    const userIds = new Set([
+      ...(input.recipientUserIds || []),
+      ...(input.recipientUserId ? [input.recipientUserId] : []),
+    ]);
+    const roleIds = new Set(
+      roles
+        .filter((role) => input.recipientRoleCodes?.includes(role.code))
+        .map((role) => role.id),
+    );
+    const departmentIds = new Set(input.recipientDepartmentIds || []);
+    if (input.includeChildDepartments) {
+      includeDescendants(departmentIds, departments);
+    }
+    const targeted =
+      userIds.size > 0 || roleIds.size > 0 || departmentIds.size > 0;
+    return users
+      .filter(
+        (user) =>
+          !targeted ||
+          userIds.has(user.id) ||
+          user.roleIds.some((roleId) => roleIds.has(roleId)) ||
+          Boolean(user.departmentId && departmentIds.has(user.departmentId)),
+      )
+      .map(({ id, email, phone }) => ({ id, email, phone }));
+  }
+
+  async address(userId: string, channel: ExternalNotificationChannel) {
+    const user = await this.repositories.users.get(userId);
+    if (!user || user.status !== "active") return undefined;
+    return channel === "email" ? user.email : user.phone;
+  }
+}
+
+function includeDescendants(
+  targetIds: Set<string>,
+  departments: Array<{ id: string; parentId?: string }>,
+) {
+  let changed = true;
+  while (changed) {
+    changed = false;
+    for (const department of departments) {
+      if (
+        department.parentId &&
+        targetIds.has(department.parentId) &&
+        !targetIds.has(department.id)
+      ) {
+        targetIds.add(department.id);
+        changed = true;
+      }
+    }
+  }
+}

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"],
+  };
+}