create-windy 0.2.33 → 0.3.0

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

@@ -0,0 +1,119 @@
+import { describe, expect, test } from "bun:test";
+import { createFoundationSnapshot } from "../foundation.js";
+import { createServerRuntime } from "../runtime.js";
+import { InMemoryNotificationDeliveryRepository } from "./memory-delivery-repository.js";
+import { InMemoryNotificationPreferenceRepository } from "./preference-repository.js";
+import type { NotificationRecipientDirectory } from "./recipient-directory.js";
+import { InMemoryNotificationRepository } from "./repository.js";
+import { registerNotificationRoutes } from "./routes.js";
+import { NotificationService } from "./service.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);
+  }
+}
+
+const directory: NotificationRecipientDirectory = {
+  async options() {
+    return {
+      users: [{ id: "user_dev_admin", label: "开发管理员" }],
+      roles: [{ id: "role_admin", label: "管理员", code: "developer" }],
+      departments: [{ id: "dept_platform", label: "平台部", code: "PLATFORM" }],
+    };
+  },
+  async resolve() {
+    return [{ id: "user_dev_admin", email: "admin@example.com" }];
+  },
+  async address() {
+    return "admin@example.com";
+  },
+};
+
+describe("通知扩展 API", () => {
+  test("偏好、受众、定时发布和 outbox 均经过通知 Guard", async () => {
+    const runtime = createServerRuntime({ WINDY_DEV_ADMIN_TOKEN: "token_1" });
+    const repository = new InMemoryNotificationRepository();
+    const preferences = new InMemoryNotificationPreferenceRepository();
+    const deliveries = new InMemoryNotificationDeliveryRepository();
+    const service = new NotificationService(
+      repository,
+      preferences,
+      deliveries,
+      directory,
+    );
+    const app = new FakeRouteApp();
+    registerNotificationRoutes(
+      app,
+      repository,
+      runtime,
+      createFoundationSnapshot().features,
+      service,
+    );
+    const guardContext = await runtime.createGuardContext(
+      new Request("http://localhost/api/notifications/preferences", {
+        headers: { authorization: "Bearer token_1" },
+      }),
+    );
+    const context = { guardContext, params: {}, query: {} };
+
+    expect(
+      await app.invoke(
+        "GET",
+        "/system/notifications/audience-options",
+        context,
+      ),
+    ).toMatchObject({
+      users: [{ id: "user_dev_admin" }],
+      departments: [{ id: "dept_platform" }],
+    });
+    expect(
+      await app.invoke("PUT", "/notifications/preferences", {
+        ...context,
+        body: {
+          enabledChannels: ["email"],
+          disabledCategories: ["营销"],
+        },
+      }),
+    ).toMatchObject({
+      userId: "user_dev_admin",
+      enabledChannels: ["email"],
+      disabledCategories: ["营销"],
+    });
+    const published = (await app.invoke("POST", "/system/notifications", {
+      ...context,
+      body: {
+        title: "定向通知",
+        summary: "摘要",
+        content: "正文",
+        category: "运营",
+        recipientUserIds: ["user_dev_admin"],
+        deliveryChannels: ["email"],
+      },
+    })) as { id: string };
+    expect(
+      await app.invoke("GET", "/system/notifications/:id/deliveries", {
+        ...context,
+        params: { id: published.id },
+      }),
+    ).toMatchObject([{ channel: "email", status: "pending" }]);
+    expect(runtime.auditSink.list().map(({ action }) => action)).toContain(
+      "notification.preference.update",
+    );
+  });
+});

package/template/apps/server/src/notification/extension-routes.ts

@@ -0,0 +1,111 @@
+import type { FeatureFlagDefinition, HttpMethod } from "@southwind-ai/shared";
+import { evaluateRouteGuards } from "../route-guards.js";
+import type { createServerRuntime } from "../runtime.js";
+import type { NotificationRouteApp } from "./routes.js";
+import {
+  notificationEvent,
+  parsePreferenceInput,
+  type NotificationRouteContext,
+} from "./route-support.js";
+import type { NotificationService } from "./service.js";
+
+type ServerRuntime = ReturnType<typeof createServerRuntime>;
+
+export function registerNotificationExtensionRoutes(
+  app: NotificationRouteApp,
+  service: NotificationService,
+  runtime: ServerRuntime,
+  feature: FeatureFlagDefinition | undefined,
+) {
+  app.get("/notifications/preferences", (raw) =>
+    guarded(
+      raw,
+      "GET",
+      "/api/notifications/preferences",
+      "read",
+      feature,
+      runtime,
+      async (context) =>
+        (await service.getPreference(context.guardContext.actor.id)) || {
+          userId: context.guardContext.actor.id,
+          enabledChannels: [],
+          disabledCategories: [],
+        },
+    ),
+  );
+  app.put("/notifications/preferences", (raw) =>
+    guarded(
+      raw,
+      "PUT",
+      "/api/notifications/preferences",
+      "read",
+      feature,
+      runtime,
+      async (context) => {
+        const input = parsePreferenceInput(context.body);
+        if (input instanceof Response) return input;
+        const preference = await service.savePreference(
+          context.guardContext.actor.id,
+          input,
+          context.guardContext.actor.id,
+        );
+        await runtime.auditSink.recordCriticalEvent(
+          notificationEvent(
+            context,
+            "notification.preference.update",
+            context.guardContext.actor.id,
+          ),
+        );
+        return preference;
+      },
+    ),
+  );
+  app.get("/system/notifications/audience-options", (raw) =>
+    guarded(
+      raw,
+      "GET",
+      "/api/system/notifications/audience-options",
+      "manage",
+      feature,
+      runtime,
+      () => service.audienceOptions(),
+    ),
+  );
+  app.get("/system/notifications/:id/deliveries", (raw) =>
+    guarded(
+      raw,
+      "GET",
+      "/api/system/notifications/:id/deliveries",
+      "manage",
+      feature,
+      runtime,
+      (context) => service.listDeliveries(context.params.id || ""),
+    ),
+  );
+}
+
+async function guarded(
+  raw: unknown,
+  method: HttpMethod,
+  path: string,
+  action: "read" | "manage",
+  feature: FeatureFlagDefinition | undefined,
+  runtime: ServerRuntime,
+  handler: (context: NotificationRouteContext) => unknown,
+) {
+  const context = raw as NotificationRouteContext;
+  const decision = await evaluateRouteGuards(runtime, context.guardContext, {
+    permission: {
+      method,
+      path,
+      permissionKey: `system.notification.${action}`,
+    },
+    feature,
+  });
+  return decision.allowed
+    ? handler(context)
+    : Response.json(
+        { error: "FORBIDDEN", reason: decision.reason },
+        { status: 403 },
+      );
+}

package/template/apps/server/src/notification/memory-delivery-repository.ts

@@ -0,0 +1,137 @@
+import type {
+  NotificationDelivery,
+  NotificationDeliveryStatus,
+} from "@southwind-ai/shared";
+import type {
+  ClaimedNotificationDelivery,
+  NotificationDeliveryDraft,
+  NotificationDeliveryRepository,
+} from "./delivery-repository.js";
+
+interface MemoryDelivery extends NotificationDeliveryDraft {
+  id: string;
+  status: NotificationDeliveryStatus;
+  attemptCount: number;
+  nextAttemptAt: string;
+  leaseToken?: string;
+  leaseExpiresAt?: string;
+  deliveredAt?: string;
+  lastErrorCode?: string;
+  createdAt: string;
+  updatedAt: string;
+}
+
+export class InMemoryNotificationDeliveryRepository implements NotificationDeliveryRepository {
+  private readonly items = new Map<string, MemoryDelivery>();
+  private readonly uniqueKeys = new Set<string>();
+
+  constructor(private readonly leaseMs = 30_000) {}
+
+  async enqueue(drafts: NotificationDeliveryDraft[]) {
+    let inserted = 0;
+    const now = new Date().toISOString();
+    for (const draft of drafts) {
+      const key = `${draft.notificationId}:${draft.userId}:${draft.channel}`;
+      if (this.uniqueKeys.has(key)) continue;
+      const id = Bun.randomUUIDv7();
+      this.items.set(id, {
+        id,
+        ...draft,
+        status: "pending",
+        attemptCount: 0,
+        nextAttemptAt: now,
+        createdAt: now,
+        updatedAt: now,
+      });
+      this.uniqueKeys.add(key);
+      inserted += 1;
+    }
+    return inserted;
+  }
+
+  async claim(now: Date, limit: number) {
+    const claimed: ClaimedNotificationDelivery[] = [];
+    for (const item of this.items.values()) {
+      const due =
+        ((item.status === "pending" || item.status === "retrying") &&
+          item.nextAttemptAt <= now.toISOString()) ||
+        (item.status === "processing" &&
+          Boolean(
+            item.leaseExpiresAt && item.leaseExpiresAt <= now.toISOString(),
+          ));
+      if (!due || claimed.length >= limit) continue;
+      const leaseToken = Bun.randomUUIDv7();
+      item.status = "processing";
+      item.attemptCount += 1;
+      item.leaseToken = leaseToken;
+      item.leaseExpiresAt = new Date(
+        now.getTime() + this.leaseMs,
+      ).toISOString();
+      item.updatedAt = now.toISOString();
+      claimed.push({
+        id: item.id,
+        notificationId: item.notificationId,
+        userId: item.userId,
+        channel: item.channel,
+        subject: item.subject,
+        content: item.content,
+        attemptCount: item.attemptCount,
+        leaseToken,
+      });
+    }
+    return claimed;
+  }
+
+  async complete(id: string, leaseToken: string) {
+    const item = this.activeLease(id, leaseToken);
+    if (!item) return false;
+    item.status = "delivered";
+    item.deliveredAt = new Date().toISOString();
+    item.updatedAt = item.deliveredAt;
+    item.leaseToken = undefined;
+    item.leaseExpiresAt = undefined;
+    item.lastErrorCode = undefined;
+    return true;
+  }
+
+  async fail(id: string, leaseToken: string, code: string, retryAt?: Date) {
+    const item = this.activeLease(id, leaseToken);
+    if (!item) return false;
+    item.status = retryAt ? "retrying" : "dead";
+    item.nextAttemptAt = (retryAt || new Date()).toISOString();
+    item.lastErrorCode = code;
+    item.updatedAt = new Date().toISOString();
+    item.leaseToken = undefined;
+    item.leaseExpiresAt = undefined;
+    return true;
+  }
+
+  async list(notificationId: string) {
+    return [...this.items.values()]
+      .filter((item) => item.notificationId === notificationId)
+      .map(toDelivery);
+  }
+
+  private activeLease(id: string, leaseToken: string) {
+    const item = this.items.get(id);
+    return item?.status === "processing" && item.leaseToken === leaseToken
+      ? item
+      : undefined;
+  }
+}
+
+function toDelivery(item: MemoryDelivery): NotificationDelivery {
+  return {
+    id: item.id,
+    notificationId: item.notificationId,
+    userId: item.userId,
+    channel: item.channel,
+    status: item.status,
+    attemptCount: item.attemptCount,
+    nextAttemptAt: item.nextAttemptAt,
+    deliveredAt: item.deliveredAt,
+    lastErrorCode: item.lastErrorCode,
+    createdAt: item.createdAt,
+    updatedAt: item.updatedAt,
+  };
+}

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