create-windy 0.2.34 → 0.3.0

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

@@ -0,0 +1,180 @@
+import {
+  notificationRevisions,
+  platformNotifications,
+} from "@southwind-ai/database";
+import type {
+  NotificationRevision,
+  PageResult,
+  PublishNotificationInput,
+  UpdateNotificationInput,
+} from "@southwind-ai/shared";
+import { and, desc, eq, inArray, sql } from "drizzle-orm";
+import type { NodePgDatabase } from "drizzle-orm/node-postgres";
+import type { RequestActor } from "../guards.js";
+import { toNotification, toRevision } from "./drizzle-query.js";
+
+export function publishNotification(
+  db: NodePgDatabase,
+  input: PublishNotificationInput,
+  actor: RequestActor,
+) {
+  return db.transaction(async (tx) => {
+    const now = new Date();
+    const [row] = await tx
+      .insert(platformNotifications)
+      .values({
+        id: Bun.randomUUIDv7(),
+        ...input,
+        scheduledFor: input.scheduledFor
+          ? new Date(input.scheduledFor)
+          : undefined,
+        status: input.scheduledFor ? "scheduled" : "published",
+        publishedAt: input.scheduledFor ? new Date(input.scheduledFor) : now,
+        createdAt: now,
+        createdBy: actor.id,
+        updatedAt: now,
+        updatedBy: actor.id,
+        revision: 1,
+      })
+      .onConflictDoNothing()
+      .returning();
+    if (!row && input.sourceKey) {
+      const [existing] = await tx
+        .select()
+        .from(platformNotifications)
+        .where(eq(platformNotifications.sourceKey, input.sourceKey))
+        .limit(1);
+      if (existing) return toNotification(existing);
+    }
+    if (!row) throw new Error("通知发布未返回记录");
+    await tx.insert(notificationRevisions).values({
+      notificationId: row.id,
+      revision: row.revision,
+      title: row.title,
+      summary: row.summary,
+      content: row.content,
+      category: row.category,
+      editedAt: now,
+      editedBy: actor.id,
+    });
+    return toNotification(row);
+  });
+}
+
+export function updateNotification(
+  db: NodePgDatabase,
+  notificationId: string,
+  input: UpdateNotificationInput,
+  actor: RequestActor,
+) {
+  return db.transaction(async (tx) => {
+    const [current] = await tx
+      .select()
+      .from(platformNotifications)
+      .where(
+        and(
+          eq(platformNotifications.id, notificationId),
+          eq(platformNotifications.status, "published"),
+        ),
+      )
+      .for("update")
+      .limit(1);
+    if (!current) return undefined;
+    if (sameContent(current, input)) {
+      return { notification: toNotification(current), changed: false };
+    }
+    const editedAt = new Date();
+    const [updated] = await tx
+      .update(platformNotifications)
+      .set({
+        ...input,
+        revision: sql`${platformNotifications.revision} + 1`,
+        updatedAt: editedAt,
+        updatedBy: actor.id,
+      })
+      .where(eq(platformNotifications.id, notificationId))
+      .returning();
+    if (!updated) throw new Error("通知更新未返回记录");
+    await tx.insert(notificationRevisions).values({
+      notificationId,
+      revision: updated.revision,
+      title: updated.title,
+      summary: updated.summary,
+      content: updated.content,
+      category: updated.category,
+      editedAt,
+      editedBy: actor.id,
+    });
+    return { notification: toNotification(updated), changed: true };
+  });
+}
+
+export async function listNotificationRevisions(
+  db: NodePgDatabase,
+  notificationId: string,
+  page: number,
+  pageSize: number,
+): Promise<PageResult<NotificationRevision> | undefined> {
+  const [notification] = await db
+    .select({ id: platformNotifications.id })
+    .from(platformNotifications)
+    .where(eq(platformNotifications.id, notificationId))
+    .limit(1);
+  if (!notification) return undefined;
+  const [rows, [{ count = 0 } = { count: 0 }]] = await Promise.all([
+    db
+      .select()
+      .from(notificationRevisions)
+      .where(eq(notificationRevisions.notificationId, notificationId))
+      .orderBy(desc(notificationRevisions.revision))
+      .limit(pageSize)
+      .offset((page - 1) * pageSize),
+    db
+      .select({ count: sql<number>`count(*)::int` })
+      .from(notificationRevisions)
+      .where(eq(notificationRevisions.notificationId, notificationId)),
+  ]);
+  return {
+    items: rows.map(toRevision),
+    total: count,
+    page,
+    pageSize,
+  };
+}
+
+export async function archiveNotification(
+  db: NodePgDatabase,
+  notificationId: string,
+  actor: RequestActor,
+) {
+  const now = new Date();
+  const [row] = await db
+    .update(platformNotifications)
+    .set({
+      status: "archived",
+      archivedAt: now,
+      archivedBy: actor.id,
+      updatedAt: now,
+      updatedBy: actor.id,
+    })
+    .where(
+      and(
+        eq(platformNotifications.id, notificationId),
+        inArray(platformNotifications.status, ["published", "scheduled"]),
+      ),
+    )
+    .returning();
+  return row ? toNotification(row) : undefined;
+}
+
+function sameContent(
+  current: typeof platformNotifications.$inferSelect,
+  input: UpdateNotificationInput,
+) {
+  return (
+    current.title === input.title &&
+    current.summary === input.summary &&
+    current.content === input.content &&
+    current.category === input.category
+  );
+}

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

@@ -0,0 +1,160 @@
+import {
+  notificationFavorites,
+  notificationReads,
+  notificationRevisions,
+  platformNotifications,
+} from "@southwind-ai/database";
+import type {
+  NotificationInboxFilters,
+  NotificationRevision,
+  PlatformNotification,
+} from "@southwind-ai/shared";
+import {
+  and,
+  eq,
+  ilike,
+  isNotNull,
+  isNull,
+  or,
+  sql,
+  type SQL,
+} from "drizzle-orm";
+import type { RequestActor } from "../guards.js";
+
+export 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(),
+    scheduledFor: row.scheduledFor?.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,
+    recipientUserIds: row.recipientUserIds,
+    recipientRoleCodes: row.recipientRoleCodes,
+    recipientDepartmentIds: row.recipientDepartmentIds,
+    includeChildDepartments: row.includeChildDepartments,
+    deliveryChannels: row.deliveryChannels,
+    sourceKey: row.sourceKey || undefined,
+    revision: row.revision,
+  };
+}
+
+export function toRevision(
+  row: typeof notificationRevisions.$inferSelect,
+): NotificationRevision {
+  return {
+    notificationId: row.notificationId,
+    revision: row.revision,
+    title: row.title,
+    summary: row.summary,
+    content: row.content,
+    category: row.category,
+    editedAt: row.editedAt.toISOString(),
+    editedBy: row.editedBy,
+  };
+}
+
+export function audienceWhere(
+  actor: Pick<RequestActor, "id" | "roleCodes" | "scopeContext">,
+): 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.recipientUserIds}) = 0`,
+      sql`jsonb_array_length(${platformNotifications.recipientRoleCodes}) = 0`,
+      sql`jsonb_array_length(${platformNotifications.recipientDepartmentIds}) = 0`,
+    ),
+    eq(platformNotifications.recipientUserId, actor.id),
+    sql`${platformNotifications.recipientUserIds} @> ${JSON.stringify([actor.id])}::jsonb`,
+    ...(actor.scopeContext?.departmentId
+      ? [
+          sql`(
+            ${platformNotifications.recipientDepartmentIds} @>
+              ${JSON.stringify([actor.scopeContext.departmentId])}::jsonb
+            or (
+              ${platformNotifications.includeChildDepartments} = true
+              and exists (
+                with recursive ancestors as (
+                  select id, parent_id from departments
+                   where id = ${actor.scopeContext.departmentId}
+                  union all
+                  select department.id, department.parent_id
+                    from departments department
+                    join ancestors child on child.parent_id = department.id
+                )
+                select 1 from ancestors
+                 where ${platformNotifications.recipientDepartmentIds} @>
+                   jsonb_build_array(ancestors.id)
+              )
+            )
+          )`,
+        ]
+      : []),
+    ...roleClauses,
+  )!;
+}
+
+export function inboxWhere(
+  actor: Pick<RequestActor, "id" | "roleCodes" | "scopeContext">,
+  filters: NotificationInboxFilters,
+): SQL {
+  const conditions: SQL[] = [
+    eq(platformNotifications.status, "published"),
+    audienceWhere(actor),
+  ];
+  const keyword = filters.q?.trim();
+  if (keyword) {
+    conditions.push(
+      or(
+        ilike(platformNotifications.title, `%${keyword}%`),
+        ilike(platformNotifications.summary, `%${keyword}%`),
+        ilike(platformNotifications.content, `%${keyword}%`),
+        ilike(platformNotifications.category, `%${keyword}%`),
+      )!,
+    );
+  }
+  const category = filters.category?.trim();
+  if (category) conditions.push(eq(platformNotifications.category, category));
+  if (filters.read !== undefined) {
+    conditions.push(
+      filters.read === "read"
+        ? isNotNull(notificationReads.readAt)
+        : isNull(notificationReads.readAt),
+    );
+  }
+  if (filters.favorite !== undefined) {
+    conditions.push(
+      filters.favorite
+        ? isNotNull(notificationFavorites.favoritedAt)
+        : isNull(notificationFavorites.favoritedAt),
+    );
+  }
+  return and(...conditions)!;
+}
+
+export 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;
+}

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