@allbluecn/web-app 0.3.0

package/src/server/serverFns/story/story-crud.ts

@@ -0,0 +1,384 @@
+// SPDX-License-Identifier: AGPL-3.0-or-later
+// AllBlue - 理想之海
+// Copyright (C) 2026 AllBlue Contributors
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Affero General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU Affero General Public License for more details.
+//
+// You should have received a copy of the GNU Affero General Public License
+// along with this program. If not, see <https://www.gnu.org/licenses/>.
+
+import { createServerFn } from "@tanstack/react-start";
+import { getRequest } from "@tanstack/react-start/server";
+import { z } from "zod";
+import { prisma, Prisma } from "@allbluecn/database";
+import { requireAuth } from "@/server/auth-helpers";
+import { ensureBuiltinIndependentProject } from "@/server/builtin-project";
+import { isUserInTeam } from "@/server/team-access";
+import { BUILTIN_INDEPENDENT_DISPLAY_ID } from "@/lib/builtin-project";
+import type { ActivityItem } from "@/components/story/types";
+import { diffDescriptionBlocks } from "@/lib/story/description-diff";
+import { USER_BRIEF_SELECT, STORY_LIST_SELECT, castStoryUsers, castUserBrief, toDateOnly } from "./types";
+import { buildListWhere } from "./story-list-query";
+
+async function validateAssignee(projectId: string, assigneeId: string | null | undefined) {
+  if (!assigneeId) return;
+  const project = await prisma.project.findUnique({
+    where: { id: projectId },
+    select: { ownerId: true },
+  });
+  if (!project) throw new Error("项目不存在");
+  const ok = await isUserInTeam(project.ownerId, assigneeId);
+  if (!ok) throw new Error("负责人必须是团队成员");
+}
+
+const listSchema = z.object({
+  state: z.string().optional(),
+  priority: z.string().optional(),
+  assigneeId: z.string().optional(),
+  projectId: z.string().optional(),
+  labelId: z.string().optional(),
+  search: z.string().optional(),
+  filters: z.string().optional(),
+  archived: z.boolean().default(false),
+  take: z.number().int().min(1).max(500).default(200),
+  skip: z.number().int().min(0).default(0),
+});
+
+export const listStoriesFn = createServerFn({ method: "GET" })
+  .validator(listSchema)
+  .handler(async ({ data }) => {
+    const request = getRequest();
+    await requireAuth(request);
+
+    const where = buildListWhere(data);
+
+    const [items, total] = await Promise.all([
+      prisma.story.findMany({
+        where,
+        orderBy: [{ createdAt: "desc" }, { id: "desc" }],
+        skip: data.skip,
+        take: data.take,
+        select: STORY_LIST_SELECT,
+      }),
+      prisma.story.count({ where }),
+    ]);
+
+    return {
+      items: items.map((s) => castStoryUsers(s)),
+      total,
+      hasMore: data.skip + items.length < total,
+    };
+  });
+
+const createSchema = z.object({
+  name: z.string().min(1).max(200),
+  description: z.string().max(20000).optional(),
+  projectId: z.string().optional(),
+  parentId: z.string().optional(),
+  state: z.enum(["backlog", "todo", "in_progress", "done", "cancelled"]).default("backlog"),
+  priority: z.enum(["urgent", "high", "medium", "low", "none"]).default("none"),
+  assigneeId: z.string().nullable().optional(),
+  startDate: z.string().optional(),
+  targetDate: z.string().optional(),
+  labelIds: z.array(z.string()).default([]),
+  isAI: z.boolean().default(false),
+});
+
+export const createStoryFn = createServerFn({ method: "POST" })
+  .validator(createSchema)
+  .handler(async ({ data }) => {
+    const request = getRequest();
+    const session = await requireAuth(request);
+    const userId = session.user!.id!;
+
+    let projectId = data.projectId;
+    if (!projectId) {
+      projectId = await ensureBuiltinIndependentProject(userId);
+    }
+
+    await validateAssignee(projectId, data.assigneeId);
+
+    const MAX_RETRIES = 5;
+    for (let attempt = 0; attempt < MAX_RETRIES; attempt++) {
+      try {
+        return await prisma.$transaction(async (tx) => {
+          if (data.parentId) {
+            const parent = await tx.story.findUnique({ where: { id: data.parentId }, select: { id: true } });
+            if (!parent) throw new Error("父需求不存在");
+          }
+          let sequenceId: number;
+          let identifier: string;
+
+          const project = await tx.project.findUnique({
+            where: { id: projectId },
+            select: { id: true, name: true, displayId: true },
+          });
+          if (!project) throw new Error("项目不存在");
+
+          const isIndependent = project.displayId === BUILTIN_INDEPENDENT_DISPLAY_ID;
+          if (isIndependent) {
+            const counter = await tx.sequenceCounter.upsert({
+              where: { scope: "global" },
+              create: { scope: "global", seq: 1 },
+              update: { seq: { increment: 1 } },
+            });
+            sequenceId = counter.seq;
+            identifier = `STORY-${counter.seq}`;
+          } else {
+            const prefix =
+              (project.displayId ?? project.name!)
+                .replace(/[^a-zA-Z0-9]/g, "")
+                .toUpperCase() || "PRJ";
+            const counter = await tx.sequenceCounter.upsert({
+              where: { scope: projectId },
+              create: { scope: projectId, seq: 1 },
+              update: { seq: { increment: 1 } },
+            });
+            sequenceId = counter.seq;
+            identifier = `${prefix}-${counter.seq}`;
+          }
+
+          const story = await tx.story.create({
+            data: {
+              sequenceId,
+              identifier,
+              name: data.name,
+              description: data.description ?? null,
+              projectId,
+              parentId: data.parentId || null,
+              state: data.state,
+              priority: data.priority,
+              assigneeId: data.assigneeId || null,
+              startDate: data.startDate ? new Date(data.startDate) : null,
+              targetDate: data.targetDate ? new Date(data.targetDate) : null,
+              createdById: userId,
+              labels: data.labelIds.length
+                ? { create: data.labelIds.map((labelId) => ({ labelId })) }
+                : undefined,
+            },
+            select: STORY_LIST_SELECT,
+          });
+
+          await tx.storyActivity.create({
+            data: { storyId: story.id, userId, action: "created", isAI: data.isAI },
+          });
+
+          return castStoryUsers(story);
+        });
+      } catch (e: unknown) {
+        const isUniqueViolation =
+          e instanceof Error &&
+          "code" in e &&
+          (e as { code: string }).code === "P2002" &&
+          "meta" in e &&
+          Array.isArray((e as { meta?: { target?: string[] } }).meta?.target) &&
+          (e as { meta: { target: string[] } }).meta.target.includes("identifier");
+        if (!isUniqueViolation || attempt === MAX_RETRIES - 1) throw e;
+      }
+    }
+    throw new Error("创建需求失败：编号冲突，请重试");
+  });
+
+const updateSchema = z.object({
+  storyId: z.string(),
+  name: z.string().min(1).max(200).optional(),
+  description: z.string().max(20000).optional(),
+  state: z.enum(["backlog", "todo", "in_progress", "done", "cancelled"]).optional(),
+  priority: z.enum(["urgent", "high", "medium", "low", "none"]).optional(),
+  assigneeId: z.string().nullable().optional(),
+  projectId: z.string().nullable().optional(),
+  startDate: z.string().nullable().optional(),
+  targetDate: z.string().nullable().optional(),
+  labelIds: z.array(z.string()).optional(),
+  parentId: z.string().nullable().optional(),
+  isAI: z.boolean().default(false),
+});
+
+export const updateStoryFn = createServerFn({ method: "POST" })
+  .validator(updateSchema)
+  .handler(async ({ data }) => {
+    const request = getRequest();
+    const session = await requireAuth(request);
+    const userId = session.user!.id!;
+
+    return prisma.$transaction(async (tx) => {
+      const existing = await tx.story.findUnique({
+        where: { id: data.storyId },
+        select: STORY_LIST_SELECT,
+      });
+      if (!existing) throw new Error("需求不存在");
+
+      if (data.assigneeId !== undefined) {
+        await validateAssignee(existing.projectId, data.assigneeId);
+      }
+
+      const updates: Prisma.StoryUpdateInput = {};
+      const activities: Array<{ action: string; field: string; oldValue: string; newValue: string }> = [];
+
+      if (data.name !== undefined && data.name !== existing.name) {
+        activities.push({ action: "name_changed", field: "name", oldValue: existing.name, newValue: data.name });
+        updates.name = data.name;
+      }
+      if (data.state !== undefined && data.state !== existing.state) {
+        activities.push({ action: "state_changed", field: "state", oldValue: existing.state, newValue: data.state });
+        updates.state = data.state;
+      }
+      if (data.priority !== undefined && data.priority !== existing.priority) {
+        activities.push({ action: "priority_changed", field: "priority", oldValue: existing.priority, newValue: data.priority });
+        updates.priority = data.priority;
+      }
+      const newAssigneeId = data.assigneeId === null ? null : (data.assigneeId ?? existing.assignee?.id ?? null);
+      if (data.assigneeId !== undefined && newAssigneeId !== (existing.assignee?.id ?? null)) {
+        if (newAssigneeId) updates.assignee = { connect: { id: newAssigneeId } };
+        else updates.assignee = { disconnect: true };
+        let newAssigneeName = "";
+        if (newAssigneeId) {
+          const newAssignee = await tx.user.findUnique({
+            where: { id: newAssigneeId },
+            select: { username: true },
+          });
+          newAssigneeName = newAssignee?.username ?? newAssigneeId;
+        }
+        activities.push({
+          action: "assignee_changed",
+          field: "assigneeId",
+          oldValue: existing.assignee?.username ?? "",
+          newValue: newAssigneeName,
+        });
+      }
+      const newProjectId = data.projectId ?? existing.projectId;
+      if (data.projectId !== undefined && newProjectId !== existing.projectId) {
+        updates.project = { connect: { id: newProjectId } };
+      }
+      if (data.startDate !== undefined) {
+        const newDate = data.startDate ? new Date(data.startDate) : null;
+        const newStart = newDate ? toDateOnly(newDate) : "";
+        const oldStart = existing.startDate ? toDateOnly(existing.startDate) : "";
+        if (newStart !== oldStart) {
+          activities.push({ action: "startDate_changed", field: "startDate", oldValue: oldStart, newValue: newStart });
+          updates.startDate = newDate;
+        }
+      }
+      if (data.targetDate !== undefined) {
+        const newDate = data.targetDate ? new Date(data.targetDate) : null;
+        const newTarget = newDate ? toDateOnly(newDate) : "";
+        const oldTarget = existing.targetDate ? toDateOnly(existing.targetDate) : "";
+        if (newTarget !== oldTarget) {
+          activities.push({ action: "targetDate_changed", field: "targetDate", oldValue: oldTarget, newValue: newTarget });
+          updates.targetDate = newDate;
+        }
+      }
+      if (data.description !== undefined && data.description !== existing.description) {
+        const diffs = diffDescriptionBlocks(existing.description, data.description);
+        for (const d of diffs) {
+          activities.push({
+            action: "description_changed",
+            field: "description",
+            oldValue: d.oldValue,
+            newValue: d.newValue,
+          });
+        }
+        updates.description = data.description;
+      }
+
+      if (data.labelIds !== undefined) {
+        updates.labels = {
+          deleteMany: {},
+          create: data.labelIds.map((labelId) => ({ labelId })),
+        };
+      }
+
+      if (data.parentId !== undefined) {
+        const newParentId = data.parentId;
+        const oldParentId = existing.parentId;
+        if (newParentId !== oldParentId) {
+          if (newParentId) {
+            const parentStory = await tx.story.findUnique({
+              where: { id: newParentId },
+              select: { id: true, name: true, identifier: true },
+            });
+            if (!parentStory) throw new Error("父需求不存在");
+            updates.parent = { connect: { id: newParentId } };
+            activities.push({
+              action: "parent_changed",
+              field: "parentId",
+              oldValue: existing.parent
+                ? `${existing.parent.identifier ?? ""} ${existing.parent.name}`.trim()
+                : "",
+              newValue: `${parentStory.identifier} ${parentStory.name}`,
+            });
+          } else {
+            updates.parent = { disconnect: true };
+            activities.push({
+              action: "parent_changed",
+              field: "parentId",
+              oldValue: existing.parent
+                ? `${existing.parent.identifier ?? ""} ${existing.parent.name}`.trim()
+                : "",
+              newValue: "",
+            });
+          }
+        }
+      }
+
+      updates.updatedBy = { connect: { id: userId } };
+
+      const updated = await tx.story.update({
+        where: { id: data.storyId },
+        data: updates,
+        select: STORY_LIST_SELECT,
+      });
+
+      if (activities.length > 0) {
+        const created = await Promise.all(
+          activities.map((a) =>
+            tx.storyActivity.create({
+              data: {
+                storyId: data.storyId,
+                userId,
+                action: a.action,
+                field: a.field,
+                oldValue: a.oldValue,
+                newValue: a.newValue,
+                isAI: data.isAI,
+              },
+              select: {
+                id: true,
+                action: true,
+                field: true,
+                oldValue: true,
+                newValue: true,
+                isAI: true,
+                createdAt: true,
+                user: { select: USER_BRIEF_SELECT },
+              },
+            })
+          )
+        );
+        return { story: castStoryUsers(updated), activities: created.map((a) => ({ ...a, isAI: a.isAI, createdAt: a.createdAt.toISOString(), user: castUserBrief(a.user) } satisfies ActivityItem)) };
+      }
+
+      return { story: castStoryUsers(updated), activities: [] as ActivityItem[] };
+    });
+  });
+
+const deleteSchema = z.object({ storyId: z.string() });
+
+export const deleteStoryFn = createServerFn({ method: "POST" })
+  .validator(deleteSchema)
+  .handler(async ({ data }) => {
+    const request = getRequest();
+    const session = await requireAuth(request);
+    const userId = session.user!.id!;
+
+    await prisma.story.delete({ where: { id: data.storyId } });
+    return { success: true };
+  });

package/src/server/serverFns/story/story-dependencies.ts

@@ -0,0 +1,218 @@
+// SPDX-License-Identifier: AGPL-3.0-or-later
+// AllBlue - 理想之海
+// Copyright (C) 2026 AllBlue Contributors
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Affero General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU Affero General Public License for more details.
+//
+// You should have received a copy of the GNU Affero General Public License
+// along with this program. If not, see <https://www.gnu.org/licenses/>.
+
+import { createServerFn } from "@tanstack/react-start";
+import { getRequest } from "@tanstack/react-start/server";
+import { z } from "zod";
+import { prisma } from "@allbluecn/database";
+import { requireAuth } from "@/server/auth-helpers";
+import type { DependencyType } from "@/components/story/types";
+
+async function hasCycle(sourceId: string, targetId: string): Promise<boolean> {
+  const visited = new Set<string>();
+
+  async function dfs(currentId: string): Promise<boolean> {
+    if (visited.has(currentId)) return false;
+    visited.add(currentId);
+
+    const outgoing = await prisma.storyDependency.findMany({
+      where: { sourceId: currentId, type: "BLOCKS" },
+      select: { targetId: true },
+    });
+
+    for (const dep of outgoing) {
+      if (dep.targetId === targetId) return true;
+      if (await dfs(dep.targetId)) return true;
+    }
+
+    return false;
+  }
+
+  return dfs(sourceId);
+}
+
+export const addDependencyFn = createServerFn({ method: "POST" })
+  .validator(
+    z.object({
+      sourceId: z.string(),
+      targetId: z.string(),
+      type: z.enum(["BLOCKS", "BLOCKED_BY", "RELATES_TO"]),
+    }),
+  )
+  .handler(async ({ data }) => {
+    const request = getRequest();
+    const session = await requireAuth(request);
+
+    const existing = await prisma.storyDependency.findUnique({
+      where: {
+        sourceId_targetId_type: {
+          sourceId: data.sourceId,
+          targetId: data.targetId,
+          type: data.type,
+        },
+      },
+    });
+    if (existing) {
+      throw new Error("依赖关系已存在");
+    }
+
+    const dep = await prisma.storyDependency.create({
+      data: {
+        sourceId: data.sourceId,
+        targetId: data.targetId,
+        type: data.type,
+      },
+    });
+
+    return dep;
+  });
+
+export const removeDependencyFn = createServerFn({ method: "POST" })
+  .validator(
+    z.object({
+      sourceId: z.string(),
+      targetId: z.string(),
+      type: z.enum(["BLOCKS", "BLOCKED_BY", "RELATES_TO"]),
+    }),
+  )
+  .handler(async ({ data }) => {
+    const request = getRequest();
+    const session = await requireAuth(request);
+
+    const dep = await prisma.storyDependency.delete({
+      where: {
+        sourceId_targetId_type: {
+          sourceId: data.sourceId,
+          targetId: data.targetId,
+          type: data.type,
+        },
+      },
+    });
+
+    return dep;
+  });
+
+export const getDependenciesFn = createServerFn({ method: "GET" })
+  .validator(z.object({ storyId: z.string() }))
+  .handler(async ({ data }) => {
+    const request = getRequest();
+    const session = await requireAuth(request);
+
+    const deps = await prisma.storyDependency.findMany({
+      where: {
+        OR: [{ sourceId: data.storyId }, { targetId: data.storyId }],
+      },
+      include: {
+        source: {
+          select: { id: true, name: true, state: true },
+        },
+        target: {
+          select: { id: true, name: true, state: true },
+        },
+      },
+    });
+
+    const grouped = {
+      blocking: deps
+        .filter((d) => d.sourceId === data.storyId && d.type === "BLOCKS")
+        .map((d) => ({
+          id: d.target.id,
+          title: d.target.name,
+          status: d.target.state,
+          type: "blocks" as DependencyType,
+        })),
+      blockedBy: deps
+        .filter((d) => d.targetId === data.storyId && d.type === "BLOCKS")
+        .map((d) => ({
+          id: d.source.id,
+          title: d.source.name,
+          status: d.source.state,
+          type: "blocked_by" as DependencyType,
+        })),
+      relatesTo: deps
+        .filter((d) => d.type === "RELATES_TO")
+        .map((d) => {
+          const isSource = d.sourceId === data.storyId;
+          const other = isSource ? d.target : d.source;
+          return {
+            id: other.id,
+            title: other.name,
+            status: other.state,
+            type: "relates_to" as DependencyType,
+          };
+        }),
+    };
+
+    return grouped;
+  });
+
+export const validateDependencyFn = createServerFn({ method: "POST" })
+  .validator(
+    z.object({
+      sourceId: z.string(),
+      targetId: z.string(),
+      type: z.enum(["BLOCKS", "BLOCKED_BY", "RELATES_TO"]),
+    }),
+  )
+  .handler(async ({ data }) => {
+    const request = getRequest();
+    const session = await requireAuth(request);
+
+    if (data.sourceId === data.targetId) {
+      return { valid: false, reason: "不能创建自我依赖" };
+    }
+
+    if (data.type === "BLOCKS") {
+      const reverse = await prisma.storyDependency.findUnique({
+        where: {
+          sourceId_targetId_type: {
+            sourceId: data.targetId,
+            targetId: data.sourceId,
+            type: "BLOCKS",
+          },
+        },
+      });
+      if (!reverse) {
+        return {
+          valid: false,
+          reason: "blocks 依赖必须成对出现（需要同时创建反向 blocks）",
+        };
+      }
+    }
+
+    const source = await prisma.story.findUnique({
+      where: { id: data.sourceId },
+      select: { parentId: true },
+    });
+    const target = await prisma.story.findUnique({
+      where: { id: data.targetId },
+      select: { parentId: true },
+    });
+
+    if (source?.parentId === data.targetId || target?.parentId === data.sourceId) {
+      return {
+        valid: false,
+        reason: "父子需求之间不能有 blocks/blocked_by 依赖",
+      };
+    }
+
+    if (await hasCycle(data.sourceId, data.targetId)) {
+      return { valid: false, reason: "会形成循环依赖" };
+    }
+
+    return { valid: true };
+  });