create-windy 0.2.17 → 0.2.18

package/template/apps/server/src/settings/watermark-routes.test.ts

@@ -0,0 +1,203 @@
+import { describe, expect, test } from "bun:test";
+import type { PlatformWatermarkPolicy } from "@southwind-ai/shared";
+import { createFoundationSnapshot } from "../foundation.js";
+import type { RequestActor } from "../guards.js";
+import { createServerRuntime } from "../runtime.js";
+import type { RouteApp } from "../system/route-types.js";
+import {
+  InMemoryWatermarkPolicyRepository,
+  type WatermarkPolicyRepository,
+} from "./watermark-repository.js";
+import { registerWatermarkPolicyRoutes } from "./watermark-routes.js";
+
+class FakeRouteApp implements RouteApp {
+  readonly handlers = new Map<string, (context: unknown) => unknown>();
+
+  get(path: string, handler: (context: unknown) => unknown): void {
+    this.handlers.set(`GET ${path}`, handler);
+  }
+
+  post(): void {}
+
+  put(path: string, handler: (context: unknown) => unknown): void {
+    this.handlers.set(`PUT ${path}`, handler);
+  }
+
+  delete(): void {}
+
+  invoke(method: "GET" | "PUT", path: string, context: unknown = {}): unknown {
+    const handler = this.handlers.get(`${method} ${path}`);
+    if (!handler) throw new Error(`未注册路由 ${method} ${path}`);
+    return handler(context);
+  }
+}
+
+describe("平台水印策略路由", () => {
+  test("公开端点无需登录即可读取全局策略", async () => {
+    const fixture = await createFixture(anonymousActor());
+
+    const policy = (await fixture.app.invoke(
+      "GET",
+      "/platform/watermark-policy",
+    )) as PlatformWatermarkPolicy;
+
+    expect(policy).toEqual({
+      enabled: true,
+      businessPagesEnabled: false,
+      customContent: "",
+    });
+  });
+
+  test("管理员保存的策略对公开端点生效并写入审计", async () => {
+    const fixture = await createFixture(settingsActor(true));
+    const input: PlatformWatermarkPolicy = {
+      enabled: true,
+      businessPagesEnabled: true,
+      customContent: "内部资料",
+    };
+
+    const updated = (await fixture.app.invoke(
+      "PUT",
+      "/system/settings/watermark",
+      {
+        guardContext: fixture.guardContext,
+        body: input,
+        params: {},
+        query: {},
+      },
+    )) as PlatformWatermarkPolicy;
+    const publicPolicy = (await fixture.app.invoke(
+      "GET",
+      "/platform/watermark-policy",
+    )) as PlatformWatermarkPolicy;
+
+    expect(updated).toEqual(input);
+    expect(publicPolicy).toEqual(input);
+    expect(fixture.runtime.auditSink.list()).toEqual(
+      expect.arrayContaining([
+        expect.objectContaining({
+          action: "config.update",
+          target: { type: "platform-watermark", id: "platform" },
+          metadata: expect.objectContaining({
+            changedFields: ["businessPagesEnabled", "customContent"],
+          }),
+        }),
+      ]),
+    );
+  });
+
+  test("只读管理员可以读取策略但不能修改", async () => {
+    const fixture = await createFixture(settingsActor(false));
+
+    const readable = (await fixture.app.invoke(
+      "GET",
+      "/system/settings/watermark",
+      { guardContext: fixture.guardContext, params: {}, query: {} },
+    )) as PlatformWatermarkPolicy;
+    const denied = (await update(fixture, {
+      enabled: false,
+      businessPagesEnabled: false,
+      customContent: "",
+    })) as Response;
+
+    expect(readable.enabled).toBe(true);
+    expect(denied.status).toBe(403);
+    await expect(denied.json()).resolves.toMatchObject({
+      reason: "missing-permission",
+    });
+  });
+
+  test("Feature 关闭时拒绝管理读取但公开策略仍可读取", async () => {
+    const fixture = await createFixture(settingsActor(true), false);
+
+    const denied = (await fixture.app.invoke(
+      "GET",
+      "/system/settings/watermark",
+      { guardContext: fixture.guardContext, params: {}, query: {} },
+    )) as Response;
+    const publicPolicy = (await fixture.app.invoke(
+      "GET",
+      "/platform/watermark-policy",
+    )) as PlatformWatermarkPolicy;
+
+    expect(denied.status).toBe(403);
+    expect(publicPolicy.enabled).toBe(true);
+  });
+
+  test("非法策略返回 400 且不会覆盖已保存值", async () => {
+    const fixture = await createFixture(settingsActor(true));
+
+    const response = (await update(fixture, {
+      enabled: true,
+      businessPagesEnabled: true,
+      customContent: "x".repeat(81),
+    })) as Response;
+
+    expect(response.status).toBe(400);
+    expect(await fixture.repository.get()).toEqual({
+      enabled: true,
+      businessPagesEnabled: false,
+      customContent: "",
+    });
+    expect(fixture.runtime.auditSink.list()).toHaveLength(0);
+  });
+});
+
+async function update(
+  fixture: Awaited<ReturnType<typeof createFixture>>,
+  body: PlatformWatermarkPolicy,
+) {
+  return fixture.app.invoke("PUT", "/system/settings/watermark", {
+    guardContext: fixture.guardContext,
+    body,
+    params: {},
+    query: {},
+  });
+}
+
+async function createFixture(actor: RequestActor, featureEnabled = true) {
+  const snapshot = createFoundationSnapshot();
+  const repository: WatermarkPolicyRepository =
+    new InMemoryWatermarkPolicyRepository();
+  const runtime = createServerRuntime(
+    {},
+    {
+      actorResolver: { resolve: () => actor },
+      featureResolver: {
+        resolve: (key) => ({
+          key,
+          enabled: featureEnabled,
+          visible: "visible",
+        }),
+      },
+    },
+  );
+  const app = new FakeRouteApp();
+  registerWatermarkPolicyRoutes(app, repository, runtime, snapshot.features);
+  const guardContext = await runtime.createGuardContext(
+    new Request("http://localhost/api/system/settings/watermark"),
+  );
+  return { app, repository, runtime, guardContext };
+}
+
+function settingsActor(canManage: boolean): RequestActor {
+  return {
+    id: "user_settings",
+    type: "user",
+    name: "配置管理员",
+    roleCodes: ["admin"],
+    permissionKeys: ["system.watermark.read"].concat(
+      canManage ? "system.watermark.manage" : [],
+    ),
+  };
+}
+
+function anonymousActor(): RequestActor {
+  return {
+    id: "anonymous",
+    type: "anonymous",
+    name: "匿名用户",
+    roleCodes: [],
+    permissionKeys: [],
+  };
+}

package/template/apps/server/src/settings/watermark-routes.ts

@@ -0,0 +1,134 @@
+import type {
+  ApiPermissionBinding,
+  FeatureFlagDefinition,
+  PlatformWatermarkPolicy,
+} from "@southwind-ai/shared";
+import { evaluateRouteGuards, findFeature } from "../route-guards.js";
+import type { createServerRuntime } from "../runtime.js";
+import { resourceEvent, routeContext } from "../system/route-helpers.js";
+import type { RouteApp } from "../system/route-types.js";
+import type { WatermarkPolicyRepository } from "./watermark-repository.js";
+
+type ServerRuntime = ReturnType<typeof createServerRuntime>;
+
+const READ_BINDING = watermarkBinding("GET", "system.watermark.read");
+const MANAGE_BINDING = watermarkBinding("PUT", "system.watermark.manage");
+
+export function registerWatermarkPolicyRoutes(
+  app: RouteApp,
+  repository: WatermarkPolicyRepository,
+  runtime: ServerRuntime,
+  features: FeatureFlagDefinition[],
+): void {
+  const feature = findFeature(features, "system.watermark");
+
+  app.get("/platform/watermark-policy", () => repository.get());
+
+  app.get("/system/settings/watermark", async (rawContext) => {
+    const { guardContext } = routeContext(rawContext);
+    const denied = await guard(runtime, guardContext, READ_BINDING, feature);
+    return denied || repository.get();
+  });
+
+  app.put("/system/settings/watermark", async (rawContext) => {
+    const { body, guardContext } = routeContext(rawContext);
+    const denied = await guard(runtime, guardContext, MANAGE_BINDING, feature);
+    if (denied) return denied;
+
+    const parsed = parseWatermarkPolicy(body);
+    if (!parsed.ok) {
+      return Response.json(
+        { error: "INVALID_WATERMARK_POLICY", message: parsed.message },
+        { status: 400 },
+      );
+    }
+
+    const before = await repository.get();
+    const updated = await repository.update(
+      parsed.value,
+      guardContext.actor.id,
+    );
+    await runtime.auditSink.recordCriticalEvent(
+      resourceEvent(
+        guardContext,
+        "config.update",
+        "platform-watermark",
+        "platform",
+        { changedFields: changedFields(before, updated) },
+      ),
+    );
+    return updated;
+  });
+}
+
+async function guard(
+  runtime: ServerRuntime,
+  context: ReturnType<typeof routeContext>["guardContext"],
+  permission: ApiPermissionBinding,
+  feature: FeatureFlagDefinition | undefined,
+): Promise<Response | undefined> {
+  const decision = await evaluateRouteGuards(runtime, context, {
+    permission,
+    feature,
+  });
+  if (decision.allowed) return undefined;
+  return Response.json(
+    { error: "FORBIDDEN", reason: decision.reason },
+    { status: 403 },
+  );
+}
+
+function watermarkBinding(
+  method: "GET" | "PUT",
+  permissionKey: string,
+): ApiPermissionBinding {
+  return {
+    method,
+    path: "/api/system/settings/watermark",
+    permissionKey,
+    featureKey: "system.watermark",
+  };
+}
+
+type WatermarkParseResult =
+  | { ok: true; value: PlatformWatermarkPolicy }
+  | { ok: false; message: string };
+
+function parseWatermarkPolicy(body: unknown): WatermarkParseResult {
+  if (!body || typeof body !== "object") {
+    return { ok: false, message: "请求体必须是对象" };
+  }
+  const source = body as Record<string, unknown>;
+  if (
+    typeof source.enabled !== "boolean" ||
+    typeof source.businessPagesEnabled !== "boolean"
+  ) {
+    return { ok: false, message: "水印开关必须是布尔值" };
+  }
+  if (typeof source.customContent !== "string") {
+    return { ok: false, message: "自定义内容必须是字符串" };
+  }
+  const customContent = source.customContent.trim();
+  if (customContent.length > 80) {
+    return { ok: false, message: "自定义内容不能超过 80 个字符" };
+  }
+  return {
+    ok: true,
+    value: {
+      enabled: source.enabled,
+      businessPagesEnabled: source.businessPagesEnabled,
+      customContent,
+    },
+  };
+}
+
+function changedFields(
+  before: PlatformWatermarkPolicy,
+  after: PlatformWatermarkPolicy,
+): string[] {
+  return ["enabled", "businessPagesEnabled", "customContent"].filter(
+    (field) =>
+      before[field as keyof PlatformWatermarkPolicy] !==
+      after[field as keyof PlatformWatermarkPolicy],
+  );
+}

package/template/apps/web/runtime-server.test.ts

@@ -15,7 +15,7 @@ describe("Web 生产同源 API 代理", () => {
     );
     const handler = createWebFetchHandler({
       distDir: "/tmp/not-used",
-      apiUpstream: "http://server:3000",
+      apiUpstream: "http://server:9747",
       fetcher,
     });
 
@@ -30,7 +30,7 @@ describe("Web 生产同源 API 代理", () => {
     );
 
     const [target, init] = fetcher.mock.calls[0]!;
-    expect(String(target)).toBe("http://server:3000/api/auth/session?fresh=1");
+    expect(String(target)).toBe("http://server:9747/api/auth/session?fresh=1");
     const headers = new Headers(init?.headers);
     expect(headers.get("cookie")).toBe("windy.sid=session");
     expect(headers.get("origin")).toBe("https://platform.example");
@@ -63,7 +63,7 @@ describe("Web 生产同源 API 代理", () => {
     const fetcher = mock(async () => Response.json({ status: "ready" }));
     const handler = createWebFetchHandler({
       distDir,
-      apiUpstream: "http://server:3000",
+      apiUpstream: "http://server:9747",
       fetcher,
     });
     try {
@@ -77,7 +77,7 @@ describe("Web 生产同源 API 代理", () => {
       expect(ready.status).toBe(200);
       expect(ready.headers.get("x-request-id")).toBe("readiness-1");
       expect(String(fetcher.mock.calls[0]?.[0])).toBe(
-        "http://server:3000/api/ready",
+        "http://server:9747/api/ready",
       );
     } finally {
       await rm(distDir, { recursive: true, force: true });

package/template/apps/web/src/composables/useWatermarkSettings.ts

@@ -1,57 +1,99 @@
 import { computed, readonly, shallowRef, type Ref } from "vue";
 import type { WebAccessActor } from "@/layout/navigation";
+import {
+  loadPlatformWatermarkPolicy,
+  loadPublicWatermarkPolicy,
+  updatePlatformWatermarkPolicy,
+} from "@/services/platform-settings-api";
+import {
+  DEFAULT_PLATFORM_WATERMARK_POLICY,
+  type PlatformWatermarkPolicy,
+} from "@southwind-ai/shared";
 import {
   defaultWatermarkContent,
-  defaultWatermarkSettings,
-  parseWatermarkSettings,
-  type WatermarkSettings,
+  normalizeWatermarkPolicy,
 } from "./watermark-settings";
 
-const storageKey = "windy.watermark.settings";
-const settings = shallowRef<WatermarkSettings>(loadSettings());
+const policy = shallowRef<PlatformWatermarkPolicy>({
+  ...DEFAULT_PLATFORM_WATERMARK_POLICY,
+});
+const loading = shallowRef(false);
+const saving = shallowRef(false);
+const error = shallowRef("");
+let loaded = false;
+let pending: Promise<PlatformWatermarkPolicy> | undefined;
 
 export function useWatermarkSettings(
   actor: Readonly<Ref<WebAccessActor | undefined>>,
 ) {
   const content = computed(
-    () =>
-      settings.value.customContent.trim() ||
-      defaultWatermarkContent(actor.value),
+    () => policy.value.customContent || defaultWatermarkContent(actor.value),
   );
 
-  function update(next: WatermarkSettings) {
-    settings.value = {
-      enabled: next.enabled,
-      businessPagesEnabled: next.businessPagesEnabled,
-      customContent: next.customContent.trim().slice(0, 80),
-    };
-    persistSettings(settings.value);
-  }
-
-  function reset() {
-    update({ ...defaultWatermarkSettings });
-  }
-
   return {
-    settings: readonly(settings),
+    policy: readonly(policy),
     content,
-    update,
-    reset,
+    loading: readonly(loading),
+    saving: readonly(saving),
+    error: readonly(error),
+    ensureLoaded: () => load(false, "public"),
+    refresh: () => load(true, "public"),
+    loadManaged: () => load(true, "managed"),
+    save,
   };
 }
 
-function loadSettings(): WatermarkSettings {
-  try {
-    return parseWatermarkSettings(localStorage.getItem(storageKey));
-  } catch {
-    return { ...defaultWatermarkSettings };
+async function load(
+  force: boolean,
+  source: "public" | "managed",
+): Promise<PlatformWatermarkPolicy> {
+  if (pending) {
+    if (source === "public") return pending;
+    await pending;
   }
+  if (!force && loaded) return policy.value;
+  loading.value = true;
+  error.value = "";
+  const request =
+    source === "managed"
+      ? loadPlatformWatermarkPolicy()
+      : loadPublicWatermarkPolicy();
+  const operation = request
+    .then(applyPolicy)
+    .catch((currentError: unknown) => {
+      error.value = message(currentError);
+      if (source === "managed") throw currentError;
+      return policy.value;
+    })
+    .finally(() => {
+      loading.value = false;
+      if (pending === operation) pending = undefined;
+    });
+  pending = operation;
+  return operation;
 }
 
-function persistSettings(value: WatermarkSettings) {
+async function save(
+  next: PlatformWatermarkPolicy,
+): Promise<PlatformWatermarkPolicy> {
+  saving.value = true;
+  error.value = "";
   try {
-    localStorage.setItem(storageKey, JSON.stringify(value));
-  } catch {
-    // 禁用浏览器存储时，设置仍在当前页面会话中生效。
+    return applyPolicy(await updatePlatformWatermarkPolicy(next));
+  } catch (currentError) {
+    error.value = message(currentError);
+    throw currentError;
+  } finally {
+    saving.value = false;
   }
 }
+
+function applyPolicy(next: PlatformWatermarkPolicy): PlatformWatermarkPolicy {
+  policy.value = normalizeWatermarkPolicy(next);
+  loaded = true;
+  return policy.value;
+}
+
+function message(value: unknown): string {
+  return value instanceof Error ? value.message : String(value);
+}

package/template/apps/web/src/composables/useWatermarkSettings.webtest.ts

@@ -0,0 +1,86 @@
+import { shallowRef } from "vue";
+import { beforeEach, describe, expect, test, vi } from "vitest";
+
+const api = vi.hoisted(() => ({
+  loadPublic: vi.fn(),
+  loadManaged: vi.fn(),
+  update: vi.fn(),
+}));
+
+vi.mock("@/services/platform-settings-api", () => ({
+  loadPublicWatermarkPolicy: api.loadPublic,
+  loadPlatformWatermarkPolicy: api.loadManaged,
+  updatePlatformWatermarkPolicy: api.update,
+}));
+
+describe("全局水印策略状态", () => {
+  beforeEach(() => {
+    vi.resetModules();
+    api.loadPublic.mockReset();
+    api.loadManaged.mockReset();
+    api.update.mockReset();
+  });
+
+  test("业务端只读加载公开策略且不访问 localStorage", async () => {
+    const localStorageRead = vi.spyOn(Storage.prototype, "getItem");
+    const localStorageWrite = vi.spyOn(Storage.prototype, "setItem");
+    api.loadPublic.mockResolvedValue({
+      enabled: true,
+      businessPagesEnabled: true,
+      customContent: "全局审计",
+    });
+    const { useWatermarkSettings } = await import("./useWatermarkSettings");
+    const watermark = useWatermarkSettings(shallowRef(undefined));
+
+    await watermark.ensureLoaded();
+
+    expect(watermark.policy.value).toEqual({
+      enabled: true,
+      businessPagesEnabled: true,
+      customContent: "全局审计",
+    });
+    expect(localStorageRead).not.toHaveBeenCalled();
+    expect(localStorageWrite).not.toHaveBeenCalled();
+  });
+
+  test("管理端保存后更新所有调用方共享的策略", async () => {
+    api.loadManaged.mockResolvedValue({
+      enabled: true,
+      businessPagesEnabled: false,
+      customContent: "",
+    });
+    api.update.mockResolvedValue({
+      enabled: true,
+      businessPagesEnabled: true,
+      customContent: "  内部资料  ",
+    });
+    const { useWatermarkSettings } = await import("./useWatermarkSettings");
+    const actor = shallowRef({
+      id: "user_1",
+      type: "user" as const,
+      name: "张三",
+      roleCodes: [],
+      permissionKeys: [],
+    });
+    const first = useWatermarkSettings(actor);
+    const second = useWatermarkSettings(actor);
+
+    await first.loadManaged();
+    await first.save({
+      enabled: true,
+      businessPagesEnabled: true,
+      customContent: "内部资料",
+    });
+
+    expect(api.update).toHaveBeenCalledWith({
+      enabled: true,
+      businessPagesEnabled: true,
+      customContent: "内部资料",
+    });
+    expect(second.policy.value).toEqual({
+      enabled: true,
+      businessPagesEnabled: true,
+      customContent: "内部资料",
+    });
+  });
+});

package/template/apps/web/src/composables/watermark-settings.ts

@@ -1,16 +1,5 @@
 import type { WebAccessActor } from "@/layout/navigation";
-
-export interface WatermarkSettings {
-  enabled: boolean;
-  businessPagesEnabled: boolean;
-  customContent: string;
-}
-
-export const defaultWatermarkSettings: WatermarkSettings = {
-  enabled: true,
-  businessPagesEnabled: false,
-  customContent: "",
-};
+import type { PlatformWatermarkPolicy } from "@southwind-ai/shared";
 
 export function defaultWatermarkContent(
   actor: WebAccessActor | undefined,
@@ -25,27 +14,12 @@ export function defaultWatermarkContent(
   return [...new Set([username, identity].filter(Boolean))].join(" · ");
 }
 
-export function parseWatermarkSettings(
-  value: string | null,
-): WatermarkSettings {
-  if (!value) return { ...defaultWatermarkSettings };
-  try {
-    const parsed = JSON.parse(value) as Record<string, unknown>;
-    return {
-      enabled:
-        typeof parsed.enabled === "boolean"
-          ? parsed.enabled
-          : defaultWatermarkSettings.enabled,
-      businessPagesEnabled:
-        typeof parsed.businessPagesEnabled === "boolean"
-          ? parsed.businessPagesEnabled
-          : defaultWatermarkSettings.businessPagesEnabled,
-      customContent:
-        typeof parsed.customContent === "string"
-          ? parsed.customContent.slice(0, 80)
-          : "",
-    };
-  } catch {
-    return { ...defaultWatermarkSettings };
-  }
+export function normalizeWatermarkPolicy(
+  value: PlatformWatermarkPolicy,
+): PlatformWatermarkPolicy {
+  return {
+    enabled: value.enabled,
+    businessPagesEnabled: value.businessPagesEnabled,
+    customContent: value.customContent.trim().slice(0, 80),
+  };
 }