create-windy 0.1.0

package/template/apps/web/src/services/http.ts

@@ -0,0 +1,145 @@
+export interface ApiPage<T> {
+  items: T[];
+  total: number;
+  page: number;
+  pageSize: number;
+}
+
+export interface ApiRequestPolicy {
+  omitDevelopmentAuth?: boolean;
+  suppressUnauthorizedHandler?: boolean;
+}
+
+export interface DevelopmentAuthStatus {
+  configured: boolean;
+  active: boolean;
+}
+
+export interface ApiClientOptions {
+  apiBase: string;
+  fetcher?: typeof fetch;
+  developmentToken?: string;
+}
+
+export class ApiError extends Error {
+  constructor(
+    message: string,
+    readonly status: number,
+    readonly code?: string,
+    readonly reason?: string,
+  ) {
+    super(message);
+    this.name = "ApiError";
+  }
+}
+
+export function createApiClient(options: ApiClientOptions) {
+  const fetcher = options.fetcher || fetch;
+  const configuredToken = options.developmentToken?.trim() || undefined;
+  let developmentAuthActive = Boolean(configuredToken);
+  let unauthorizedHandler: (() => void) | undefined;
+
+  async function response(
+    path: string,
+    init: RequestInit = {},
+    policy: ApiRequestPolicy = {},
+  ): Promise<Response> {
+    const headers = new Headers(init.headers);
+    if (init.body !== undefined && !headers.has("content-type")) {
+      headers.set("content-type", "application/json");
+    }
+    if (
+      configuredToken &&
+      developmentAuthActive &&
+      !policy.omitDevelopmentAuth &&
+      !headers.has("authorization")
+    ) {
+      headers.set("authorization", `Bearer ${configuredToken}`);
+    }
+    const result = await fetcher(`${options.apiBase}${path}`, {
+      ...init,
+      credentials: init.credentials || "same-origin",
+      headers,
+    });
+
+    if (!result.ok) {
+      const error = await readApiError(result);
+      if (result.status === 401 && !policy.suppressUnauthorizedHandler) {
+        unauthorizedHandler?.();
+      }
+      throw error;
+    }
+    return result;
+  }
+
+  async function request<T>(
+    path: string,
+    init: RequestInit = {},
+    policy: ApiRequestPolicy = {},
+  ): Promise<T> {
+    const result = await response(path, init, policy);
+    if (result.status === 204) return undefined as T;
+    return result.json() as Promise<T>;
+  }
+
+  return {
+    request,
+    response,
+    setUnauthorizedHandler(handler: (() => void) | undefined) {
+      unauthorizedHandler = handler;
+    },
+    developmentAuthStatus(): DevelopmentAuthStatus {
+      return {
+        configured: Boolean(configuredToken),
+        active: developmentAuthActive,
+      };
+    },
+    suspendDevelopmentAuth() {
+      developmentAuthActive = false;
+    },
+  };
+}
+
+async function readApiError(response: Response): Promise<ApiError> {
+  try {
+    const payload = (await response.json()) as {
+      error?: string;
+      message?: string;
+      reason?: string;
+    };
+    const message =
+      payload.message ||
+      [payload.error, payload.reason].filter(Boolean).join(": ") ||
+      response.statusText;
+    return new ApiError(
+      message,
+      response.status,
+      payload.error,
+      payload.reason,
+    );
+  } catch {
+    return new ApiError(response.statusText || "请求失败", response.status);
+  }
+}
+
+function configuredDevelopmentToken(): string | undefined {
+  if (!import.meta.env.DEV || import.meta.env.VITE_DEV_AUTH_BYPASS !== "1") {
+    return undefined;
+  }
+  return import.meta.env.VITE_DEV_ADMIN_TOKEN?.trim() || undefined;
+}
+
+const client = createApiClient({
+  apiBase: import.meta.env.VITE_API_BASE || "/api",
+  developmentToken: configuredDevelopmentToken(),
+});
+
+export const apiRequest = client.request;
+export const apiResponse = client.response;
+export const setUnauthorizedHandler = client.setUnauthorizedHandler;
+export const developmentAuthStatus = client.developmentAuthStatus;
+export const suspendDevelopmentAuth = client.suspendDevelopmentAuth;
+
+export function isApiErrorStatus(error: unknown, status: number): boolean {
+  return error instanceof ApiError && error.status === status;
+}

package/template/apps/web/src/services/http.webtest.ts

@@ -0,0 +1,73 @@
+import { describe, expect, test, vi } from "vitest";
+import { ApiError, createApiClient } from "./http";
+
+describe("Web HTTP 会话策略", () => {
+  test("默认使用同源 Cookie 且不注入任何默认开发 Token", async () => {
+    const fetcher = vi.fn<typeof fetch>(async () =>
+      Response.json({ ok: true }),
+    );
+    const client = createApiClient({ apiBase: "/api", fetcher });
+
+    await client.request("/health");
+
+    const [, init] = fetcher.mock.calls[0]!;
+    expect(init?.credentials).toBe("same-origin");
+    expect(new Headers(init?.headers).has("authorization")).toBe(false);
+  });
+
+  test("原始响应入口复用认证策略但不消费下载内容", async () => {
+    const fetcher = vi.fn<typeof fetch>(async () =>
+      Response.json({ line: 1 }, { headers: { "x-artifact": "ndjson" } }),
+    );
+    const client = createApiClient({ apiBase: "/api", fetcher });
+
+    const response = await client.response("/artifacts/result");
+
+    expect(response.headers.get("x-artifact")).toBe("ndjson");
+    expect(await response.json()).toEqual({ line: 1 });
+    expect(fetcher.mock.calls[0]![1]?.credentials).toBe("same-origin");
+  });
+
+  test("只有显式配置才注入开发 Token，且真实登录可停用它", async () => {
+    const fetcher = vi.fn<typeof fetch>(async () =>
+      Response.json({ ok: true }),
+    );
+    const client = createApiClient({
+      apiBase: "/api",
+      fetcher,
+      developmentToken: "explicit-dev-token",
+    });
+
+    await client.request("/foundation");
+    expect(
+      new Headers(fetcher.mock.calls[0]![1]?.headers).get("authorization"),
+    ).toBe("Bearer explicit-dev-token");
+
+    client.suspendDevelopmentAuth();
+    await client.request("/foundation");
+    expect(
+      new Headers(fetcher.mock.calls[1]![1]?.headers).has("authorization"),
+    ).toBe(false);
+  });
+
+  test("401 触发全局清理通知，403 不会被误判成会话失效", async () => {
+    const unauthorized = vi.fn();
+    const fetcher = vi
+      .fn<typeof fetch>()
+      .mockResolvedValueOnce(
+        Response.json({ error: "UNAUTHORIZED" }, { status: 401 }),
+      )
+      .mockResolvedValueOnce(
+        Response.json({ error: "LICENSE_RESTRICTED" }, { status: 403 }),
+      );
+    const client = createApiClient({ apiBase: "/api", fetcher });
+    client.setUnauthorizedHandler(unauthorized);
+
+    await expect(client.request("/first")).rejects.toBeInstanceOf(ApiError);
+    await expect(client.request("/second")).rejects.toMatchObject({
+      status: 403,
+      code: "LICENSE_RESTRICTED",
+    });
+    expect(unauthorized).toHaveBeenCalledTimes(1);
+  });
+});

package/template/apps/web/src/services/license-api.ts

@@ -0,0 +1,53 @@
+import type { SignedLicenseV1 } from "@windy/shared";
+import { apiRequest } from "./http";
+
+export type PlatformLicenseStatus =
+  | "valid"
+  | "expired"
+  | "clock-rollback"
+  | "invalid"
+  | "missing";
+
+export type LicenseReminderLevel = "none" | "notice" | "warning" | "critical";
+
+export interface PlatformLicenseSnapshot {
+  machineCode?: string;
+  productCode?: string;
+  status: PlatformLicenseStatus;
+  restricted: boolean;
+  failures?: string[];
+  expiresAt?: string;
+  reminder: {
+    level: LicenseReminderLevel;
+    daysRemaining?: number;
+  };
+  canViewDetails: boolean;
+  license?: SignedLicenseV1;
+}
+
+interface LicenseInstallResponse {
+  installStatus: "installed" | "unchanged";
+  snapshot: PlatformLicenseSnapshot;
+}
+
+export function loadPlatformLicense(): Promise<PlatformLicenseSnapshot> {
+  return apiRequest<PlatformLicenseSnapshot>("/license/runtime");
+}
+
+export function installPlatformLicense(
+  license: string,
+): Promise<LicenseInstallResponse> {
+  return apiRequest<LicenseInstallResponse>("/license/runtime/install", {
+    method: "POST",
+    body: JSON.stringify({ license }),
+  });
+}
+
+export function installPlatformActivationCode(
+  activationCode: string,
+): Promise<LicenseInstallResponse> {
+  return apiRequest<LicenseInstallResponse>("/license/runtime/install", {
+    method: "POST",
+    body: JSON.stringify({ activationCode }),
+  });
+}

package/template/apps/web/src/services/notification-api.ts

@@ -0,0 +1,51 @@
+import type {
+  MarkNotificationReadResult,
+  NotificationInboxItem,
+  PageResult,
+  PlatformNotification,
+  PublishNotificationInput,
+} from "@windy/shared";
+import { DEFAULT_PAGE_SIZE } from "@windy/shared";
+import { apiRequest } from "./http";
+
+export function listNotifications(page = 1, pageSize = DEFAULT_PAGE_SIZE) {
+  return apiRequest<PageResult<NotificationInboxItem>>(
+    `/notifications?page=${page}&pageSize=${pageSize}`,
+  );
+}
+
+export function markNotificationRead(id: string) {
+  return apiRequest<MarkNotificationReadResult>(
+    `/notifications/${encodeURIComponent(id)}/read`,
+    { method: "POST" },
+  );
+}
+
+export function listManagedNotifications(
+  page = 1,
+  pageSize = DEFAULT_PAGE_SIZE,
+  query = "",
+) {
+  const params = new URLSearchParams({
+    page: String(page),
+    pageSize: String(pageSize),
+  });
+  if (query) params.set("q", query);
+  return apiRequest<PageResult<PlatformNotification>>(
+    `/system/notifications?${params.toString()}`,
+  );
+}
+
+export function publishNotification(input: PublishNotificationInput) {
+  return apiRequest<PlatformNotification>("/system/notifications", {
+    method: "POST",
+    body: JSON.stringify(input),
+  });
+}
+
+export function archiveNotification(id: string) {
+  return apiRequest<PlatformNotification>(
+    `/system/notifications/${encodeURIComponent(id)}`,
+    { method: "DELETE" },
+  );
+}

package/template/apps/web/src/services/operations-api.ts

@@ -0,0 +1,128 @@
+import { apiRequest } from "./http";
+import type {
+  PageResult,
+  SchedulerManualTriggerResponse,
+  SchedulerOperationsSnapshot,
+  SchedulerRunHistoryItem,
+  SchedulerStaleRecoveryRequest,
+  SchedulerStaleRecoveryResponse,
+} from "@windy/shared";
+
+export interface OperationSnapshot {
+  generatedAt: string;
+  onlineUsers: Array<{
+    sessionId: string;
+    userId: string;
+    username: string;
+    displayName: string;
+    status: string;
+    ip?: string;
+    issuedAt: string;
+    lastSeenAt: string;
+    expiresAt: string;
+  }>;
+  serviceMonitor: {
+    status: string;
+    runtime: string;
+    startedAt: string;
+    platform: string;
+    arch: string;
+    memory: {
+      processBytes: number;
+      totalBytes: number;
+      usagePercent: number;
+    };
+  };
+  databaseMonitor: {
+    status: "healthy" | "not-configured" | "unavailable";
+    engine: string;
+    version: string;
+    databaseName?: string;
+    dataBytes: number;
+    message?: string;
+  };
+  diskMonitor: {
+    host: {
+      status: "available" | "unknown";
+      source: "configured-path" | "native-host" | "unconfigured";
+      totalBytes?: number;
+      availableBytes?: number;
+      path?: string;
+      message?: string;
+    };
+    system: {
+      status: "available" | "not-configured" | "unavailable";
+      path?: string;
+      paths?: string[];
+      usedBytes?: number;
+      refreshedAt?: string;
+      refreshIntervalMs?: number;
+      message?: string;
+    };
+    data: {
+      status: "available" | "partial";
+      usedBytes: number;
+      databaseBytes: number;
+      importBytes: number;
+      importPath?: string;
+      message?: string;
+    };
+  };
+  cacheMonitor: {
+    status:
+      | "healthy"
+      | "timeout"
+      | "authentication-failed"
+      | "unavailable"
+      | "not-configured";
+    provider: "Redis";
+    message: string;
+    target?: string;
+    latencyMs?: number;
+    metrics?: {
+      connectedClients: number;
+      keyCount: number;
+      usedMemoryBytes: number;
+      maxMemoryBytes: number | null;
+      memoryUsagePercent: number | null;
+    };
+  };
+}
+
+export function getOperationSnapshot() {
+  return apiRequest<OperationSnapshot>("/system/operations");
+}
+
+export function getSchedulerOperations() {
+  return apiRequest<SchedulerOperationsSnapshot>(
+    "/system/operations/scheduler",
+  );
+}
+
+export function getScheduledTaskRuns(page: number, pageSize: number) {
+  const params = new URLSearchParams({
+    page: String(page),
+    pageSize: String(pageSize),
+  });
+  return apiRequest<PageResult<SchedulerRunHistoryItem>>(
+    `/system/scheduled-task-runs?${params.toString()}`,
+  );
+}
+
+export function triggerScheduledTask(taskKey: string) {
+  return apiRequest<SchedulerManualTriggerResponse>(
+    `/system/scheduled-tasks/${encodeURIComponent(taskKey)}/trigger`,
+    { method: "POST" },
+  );
+}
+
+export function recoverStaleScheduledRun(
+  taskKey: string,
+  runId: string,
+  request: SchedulerStaleRecoveryRequest,
+) {
+  return apiRequest<SchedulerStaleRecoveryResponse>(
+    `/system/scheduled-tasks/${encodeURIComponent(taskKey)}/runs/${encodeURIComponent(runId)}/recover`,
+    { method: "POST", body: JSON.stringify(request) },
+  );
+}

package/template/apps/web/src/services/platform-settings-api.ts

@@ -0,0 +1,21 @@
+import { apiRequest } from "./http";
+import type { PlatformBrandingSettings } from "@windy/shared";
+
+export type { PlatformBrandingSettings } from "@windy/shared";
+
+export function loadPublicBranding(): Promise<PlatformBrandingSettings> {
+  return apiRequest<PlatformBrandingSettings>("/platform/branding");
+}
+
+export function loadPlatformBranding(): Promise<PlatformBrandingSettings> {
+  return apiRequest<PlatformBrandingSettings>("/system/settings/branding");
+}
+
+export function updatePlatformBranding(
+  settings: PlatformBrandingSettings,
+): Promise<PlatformBrandingSettings> {
+  return apiRequest<PlatformBrandingSettings>("/system/settings/branding", {
+    method: "PUT",
+    body: JSON.stringify(settings),
+  });
+}

package/template/apps/web/src/services/profile-api.ts

@@ -0,0 +1,17 @@
+import type { UserProfile, UserProfileUpdate } from "@windy/shared";
+import { apiRequest } from "./http";
+
+export type { UserProfile, UserProfileUpdate } from "@windy/shared";
+
+export function loadUserProfile(): Promise<UserProfile> {
+  return apiRequest<UserProfile>("/system/profile");
+}
+
+export function updateUserProfile(
+  input: UserProfileUpdate,
+): Promise<UserProfile> {
+  return apiRequest<UserProfile>("/system/profile", {
+    method: "PUT",
+    body: JSON.stringify(input),
+  });
+}

package/template/apps/web/src/services/session-context-api.ts

@@ -0,0 +1,20 @@
+import { apiRequest } from "./http";
+
+export interface SessionContext {
+  user: {
+    id: string;
+    username?: string;
+    displayName: string;
+  };
+  capabilities: {
+    adminAccess: boolean;
+  };
+}
+
+export function loadSessionContext(): Promise<SessionContext> {
+  return apiRequest<SessionContext>(
+    "/session/context",
+    {},
+    { suppressUnauthorizedHandler: true },
+  );
+}

package/template/apps/web/src/services/system-api.ts

@@ -0,0 +1,156 @@
+import type { ApiPage } from "./http";
+import { apiRequest } from "./http";
+
+export type SystemRecord = Record<string, unknown> & {
+  id: string;
+  status?: string;
+  updatedAt?: string;
+  deletedAt?: string;
+};
+
+export interface SystemListQuery {
+  page: number;
+  pageSize: number;
+  q?: string;
+  action?: string;
+  actorId?: string;
+  occurredAfter?: string;
+  occurredBefore?: string;
+  status?: string;
+  sort?: string;
+  includeScheduler?: boolean;
+}
+
+export interface SystemExportPayload {
+  resource: string;
+  exportedAt: string;
+  total: number;
+  items: SystemRecord[];
+}
+
+export interface SystemImportResult {
+  created: number;
+  updated: number;
+  skipped: number;
+  total: number;
+  items: SystemRecord[];
+}
+
+export function listSystemResource(resource: string, query: SystemListQuery) {
+  const params = new URLSearchParams();
+  params.set("page", String(query.page));
+  params.set("pageSize", String(query.pageSize));
+  if (query.q) params.set("q", query.q);
+  if (query.action) params.set("action", query.action);
+  if (query.actorId) params.set("actorId", query.actorId);
+  if (query.occurredAfter) params.set("occurredAfter", query.occurredAfter);
+  if (query.occurredBefore) params.set("occurredBefore", query.occurredBefore);
+  if (query.status) params.set("status", query.status);
+  if (query.sort) params.set("sort", query.sort);
+  if (query.includeScheduler) params.set("includeScheduler", "true");
+  return apiRequest<ApiPage<SystemRecord>>(
+    `/system/${resource}?${params.toString()}`,
+  );
+}
+
+export function exportSystemResource(resource: string, query: SystemListQuery) {
+  const params = new URLSearchParams();
+  params.set("page", String(query.page));
+  params.set("pageSize", String(query.pageSize));
+  if (query.q) params.set("q", query.q);
+  if (query.action) params.set("action", query.action);
+  if (query.actorId) params.set("actorId", query.actorId);
+  if (query.occurredAfter) params.set("occurredAfter", query.occurredAfter);
+  if (query.occurredBefore) params.set("occurredBefore", query.occurredBefore);
+  if (query.status) params.set("status", query.status);
+  if (query.sort) params.set("sort", query.sort);
+  if (query.includeScheduler) params.set("includeScheduler", "true");
+  return apiRequest<SystemExportPayload>(
+    `/system/${resource}/export?${params.toString()}`,
+  );
+}
+
+export function importSystemResource(
+  resource: string,
+  items: Array<Record<string, unknown>>,
+  mode: "create" | "upsert" = "upsert",
+) {
+  return apiRequest<SystemImportResult>(`/system/${resource}/import`, {
+    method: "POST",
+    body: JSON.stringify({ items, mode }),
+  });
+}
+
+export function createSystemResource(
+  resource: string,
+  payload: Record<string, unknown>,
+) {
+  return apiRequest<SystemRecord>(`/system/${resource}`, {
+    method: "POST",
+    body: JSON.stringify(payload),
+  });
+}
+
+export function updateSystemResource(
+  resource: string,
+  id: string,
+  payload: Record<string, unknown>,
+) {
+  return apiRequest<SystemRecord>(`/system/${resource}/${id}`, {
+    method: "PUT",
+    body: JSON.stringify(payload),
+  });
+}
+
+export function deleteSystemResource(resource: string, id: string) {
+  return apiRequest<SystemRecord>(`/system/${resource}/${id}`, {
+    method: "DELETE",
+  });
+}
+
+export function resetSystemUserPassword(userId: string, password: string) {
+  return apiRequest<{ success: true; userId: string }>(
+    `/auth/users/${userId}/password`,
+    {
+      method: "POST",
+      body: JSON.stringify({ password }),
+    },
+  );
+}
+
+export interface MenuPlacementPayload {
+  parentKey?: string | null;
+  direction?: "up" | "down";
+  visible?: boolean;
+}
+
+export interface MenuPlacementDraft {
+  id: string;
+  parentKey?: string;
+  order: number;
+  visible: boolean;
+}
+
+export function updateMenuPlacement(id: string, payload: MenuPlacementPayload) {
+  return apiRequest<SystemRecord>(`/system/menus/${id}/placement`, {
+    method: "PUT",
+    body: JSON.stringify(payload),
+  });
+}
+
+export function updateMenuPlacements(placements: MenuPlacementDraft[]) {
+  return apiRequest<{ items: SystemRecord[]; total: number }>(
+    "/system/menus/placements",
+    {
+      method: "PUT",
+      body: JSON.stringify({ placements }),
+    },
+  );
+}
+
+export function quickCreateDepartment(payload: Record<string, unknown>) {
+  return apiRequest<SystemRecord>("/system/departments/quick", {
+    method: "POST",
+    body: JSON.stringify(payload),
+  });
+}