create-windy 0.2.34 → 0.3.0

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

@@ -1,31 +1,48 @@
-import { notificationReads, platformNotifications } from "@southwind-ai/database";
+import {
+  notificationFavorites,
+  notificationReads,
+  platformNotifications,
+} from "@southwind-ai/database";
 import type {
+  NotificationInboxFilters,
   NotificationInboxItem,
   PageResult,
   PlatformNotification,
   PublishNotificationInput,
+  UpdateNotificationInput,
 } from "@southwind-ai/shared";
-import { and, desc, eq, ilike, isNull, or, sql, type SQL } from "drizzle-orm";
+import { and, desc, eq, sql } from "drizzle-orm";
 import type { NodePgDatabase } from "drizzle-orm/node-postgres";
 import type { RequestActor } from "../guards.js";
+import {
+  audienceWhere,
+  inboxWhere,
+  searchWhere,
+  toNotification,
+} from "./drizzle-query.js";
+import {
+  archiveNotification,
+  listNotificationRevisions,
+  publishNotification,
+  updateNotification,
+} from "./drizzle-management.js";
 import type { NotificationRepository } from "./repository.js";
 
 export class DrizzleNotificationRepository implements NotificationRepository {
   constructor(private readonly db: NodePgDatabase) {}
 
   async listInbox(
-    actor: Pick<RequestActor, "id" | "roleCodes">,
+    actor: Pick<RequestActor, "id" | "roleCodes" | "scopeContext">,
     page: number,
     pageSize: number,
+    filters: NotificationInboxFilters = {},
   ) {
-    const where = and(
-      eq(platformNotifications.status, "published"),
-      audienceWhere(actor),
-    );
+    const where = inboxWhere(actor, filters);
     const rows = await this.db
       .select({
         notification: platformNotifications,
         readAt: notificationReads.readAt,
+        favoritedAt: notificationFavorites.favoritedAt,
       })
       .from(platformNotifications)
       .leftJoin(
@@ -35,6 +52,13 @@ export class DrizzleNotificationRepository implements NotificationRepository {
           eq(notificationReads.userId, actor.id),
         ),
       )
+      .leftJoin(
+        notificationFavorites,
+        and(
+          eq(notificationFavorites.notificationId, platformNotifications.id),
+          eq(notificationFavorites.userId, actor.id),
+        ),
+      )
       .where(where)
       .orderBy(desc(platformNotifications.publishedAt))
       .limit(pageSize)
@@ -42,12 +66,28 @@ export class DrizzleNotificationRepository implements NotificationRepository {
     const [{ count = 0 } = { count: 0 }] = await this.db
       .select({ count: sql<number>`count(*)::int` })
       .from(platformNotifications)
+      .leftJoin(
+        notificationReads,
+        and(
+          eq(notificationReads.notificationId, platformNotifications.id),
+          eq(notificationReads.userId, actor.id),
+        ),
+      )
+      .leftJoin(
+        notificationFavorites,
+        and(
+          eq(notificationFavorites.notificationId, platformNotifications.id),
+          eq(notificationFavorites.userId, actor.id),
+        ),
+      )
       .where(where);
     return {
-      items: rows.map(({ notification, readAt }) => ({
+      items: rows.map(({ notification, readAt, favoritedAt }) => ({
         ...toNotification(notification),
         read: Boolean(readAt),
         readAt: readAt?.toISOString(),
+        favorite: Boolean(favoritedAt),
+        favoritedAt: favoritedAt?.toISOString(),
       })),
       total: count,
       page,
@@ -85,36 +125,59 @@ export class DrizzleNotificationRepository implements NotificationRepository {
   }
 
   async publish(input: PublishNotificationInput, actor: RequestActor) {
-    const now = new Date();
+    return publishNotification(this.db, input, actor);
+  }
+
+  async listDueScheduled(now: Date, limit: number) {
+    const rows = await this.db
+      .select()
+      .from(platformNotifications)
+      .where(
+        and(
+          eq(platformNotifications.status, "scheduled"),
+          sql`${platformNotifications.scheduledFor} <= ${now}`,
+        ),
+      )
+      .orderBy(platformNotifications.scheduledFor)
+      .limit(limit);
+    return rows.map(toNotification);
+  }
+
+  async activateScheduled(notificationId: string, now: Date) {
     const [row] = await this.db
-      .insert(platformNotifications)
-      .values({
-        id: Bun.randomUUIDv7(),
-        ...input,
+      .update(platformNotifications)
+      .set({
         status: "published",
         publishedAt: now,
-        createdAt: now,
-        createdBy: actor.id,
         updatedAt: now,
-        updatedBy: actor.id,
+        updatedBy: "notification-scheduler",
       })
-      .onConflictDoNothing()
+      .where(
+        and(
+          eq(platformNotifications.id, notificationId),
+          eq(platformNotifications.status, "scheduled"),
+          sql`${platformNotifications.scheduledFor} <= ${now}`,
+        ),
+      )
       .returning();
-    if (!row && input.sourceKey) {
-      const [existing] = await this.db
-        .select()
-        .from(platformNotifications)
-        .where(eq(platformNotifications.sourceKey, input.sourceKey))
-        .limit(1);
-      if (existing) return toNotification(existing);
-    }
-    if (!row) throw new Error("通知发布未返回记录");
-    return toNotification(row);
+    return row ? toNotification(row) : undefined;
+  }
+
+  async update(
+    notificationId: string,
+    input: UpdateNotificationInput,
+    actor: RequestActor,
+  ) {
+    return updateNotification(this.db, notificationId, input, actor);
+  }
+
+  async listRevisions(notificationId: string, page: number, pageSize: number) {
+    return listNotificationRevisions(this.db, notificationId, page, pageSize);
   }
 
   async markRead(
     notificationId: string,
-    actor: Pick<RequestActor, "id" | "roleCodes">,
+    actor: Pick<RequestActor, "id" | "roleCodes" | "scopeContext">,
   ) {
     const [notification] = await this.db
       .select({ id: platformNotifications.id })
@@ -160,74 +223,77 @@ export class DrizzleNotificationRepository implements NotificationRepository {
       : undefined;
   }
 
+  async setFavorite(
+    notificationId: string,
+    favorite: boolean,
+    actor: Pick<RequestActor, "id" | "roleCodes" | "scopeContext">,
+  ) {
+    if (!(await this.isVisible(notificationId, actor))) return undefined;
+    if (!favorite) {
+      const deleted = await this.db
+        .delete(notificationFavorites)
+        .where(
+          and(
+            eq(notificationFavorites.notificationId, notificationId),
+            eq(notificationFavorites.userId, actor.id),
+          ),
+        )
+        .returning({ notificationId: notificationFavorites.notificationId });
+      return {
+        success: true,
+        favorite: false,
+        changed: Boolean(deleted[0]),
+      } as const;
+    }
+    const favoritedAt = new Date();
+    const inserted = await this.db
+      .insert(notificationFavorites)
+      .values({ notificationId, userId: actor.id, favoritedAt })
+      .onConflictDoNothing()
+      .returning({ favoritedAt: notificationFavorites.favoritedAt });
+    const persistedAt =
+      inserted[0]?.favoritedAt ||
+      (
+        await this.db
+          .select({ favoritedAt: notificationFavorites.favoritedAt })
+          .from(notificationFavorites)
+          .where(
+            and(
+              eq(notificationFavorites.notificationId, notificationId),
+              eq(notificationFavorites.userId, actor.id),
+            ),
+          )
+          .limit(1)
+      )[0]?.favoritedAt;
+    return persistedAt
+      ? ({
+          success: true,
+          favorite: true,
+          changed: Boolean(inserted[0]),
+          favoritedAt: persistedAt.toISOString(),
+        } as const)
+      : undefined;
+  }
+
   async archive(notificationId: string, actor: RequestActor) {
-    const now = new Date();
-    const [row] = await this.db
-      .update(platformNotifications)
-      .set({
-        status: "archived",
-        archivedAt: now,
-        archivedBy: actor.id,
-        updatedAt: now,
-        updatedBy: actor.id,
-      })
+    return archiveNotification(this.db, notificationId, actor);
+  }
+
+  private async isVisible(
+    notificationId: string,
+    actor: Pick<RequestActor, "id" | "roleCodes" | "scopeContext">,
+  ) {
+    const [notification] = await this.db
+      .select({ id: platformNotifications.id })
+      .from(platformNotifications)
       .where(
         and(
           eq(platformNotifications.id, notificationId),
           eq(platformNotifications.status, "published"),
+          audienceWhere(actor),
         ),
       )
-      .returning();
-    return row ? toNotification(row) : undefined;
+      .limit(1);
+    return Boolean(notification);
   }
 }
-
-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(),
-    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,
-    recipientRoleCodes: row.recipientRoleCodes,
-    sourceKey: row.sourceKey || undefined,
-  };
-}
-
-function audienceWhere(actor: Pick<RequestActor, "id" | "roleCodes">): 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.recipientRoleCodes}) = 0`,
-    ),
-    eq(platformNotifications.recipientUserId, actor.id),
-    ...roleClauses,
-  )!;
-}
-
-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/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,
+  };
+}