@allbluecn/web-app 0.3.0

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

@@ -0,0 +1,279 @@
+// 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 { GROUP_KEYS, ORDER_KEYS, ORDER_DIRECTIONS, type GroupKey, type OrderKey } from "@/components/story/display/types";
+import { STORY_STATES, STORY_PRIORITIES } from "@/components/story/constants";
+import { STORY_LIST_SELECT_LIGHT, castStoryUsersLight, type StoryListRowLight } from "./types";
+import { buildListWhere, buildGroupFilter } from "./story-list-query";
+
+const ORDER_FIELD: Record<OrderKey, Prisma.StoryScalarFieldEnum | null> = {
+  manual: "boardOrder",
+  created: "createdAt",
+  updated: "updatedAt",
+  startDate: "startDate",
+  dueDate: "targetDate",
+  priority: "priority",
+} as const;
+
+const schema = z.object({
+  archived: z.boolean().default(false),
+  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(),
+  groupBy: z.enum(GROUP_KEYS).default("none"),
+  groupKey: z.string().default(""),
+  subGroupBy: z.enum(GROUP_KEYS).default("none"),
+  subGroupKey: z.string().default(""),
+  orderBy: z.enum(ORDER_KEYS).default("created"),
+  orderDir: z.enum(ORDER_DIRECTIONS).default("desc"),
+  take: z.number().int().min(1).max(1000).default(100),
+  skip: z.number().int().min(0).default(0),
+});
+
+export const listStoriesInGroupFn = createServerFn({ method: "GET" })
+  .validator(schema)
+  .handler(async ({ data }) => {
+    const request = getRequest();
+    await requireAuth(request);
+
+    const base = buildListWhere(data);
+    const baseAnd = Array.isArray(base.AND) ? base.AND : base.AND ? [base.AND] : [];
+    const extras: Prisma.StoryWhereInput[] = [];
+    const groupWhere = buildGroupFilter(data.groupBy, data.groupKey);
+    if (Object.keys(groupWhere).length) extras.push(groupWhere);
+    if (data.subGroupBy !== "none" && data.subGroupKey) {
+      extras.push(buildGroupFilter(data.subGroupBy, data.subGroupKey));
+    }
+    const where = extras.length ? { ...base, AND: [...baseAnd, ...extras] } : base;
+
+    const field = ORDER_FIELD[data.orderBy];
+    const dir: "asc" | "desc" = data.orderDir === "asc" ? "asc" : "desc";
+    const orderBy: Prisma.StoryOrderByWithRelationInput = field
+      ? { [field]: dir }
+      : { createdAt: dir };
+
+    const items = await prisma.story.findMany({
+      where,
+      orderBy,
+      skip: data.skip,
+      take: data.take,
+      select: STORY_LIST_SELECT_LIGHT,
+    });
+
+    const total = data.skip === 0 ? undefined : await prisma.story.count({ where });
+    const hasMore = total == null ? items.length === data.take : data.skip + items.length < total;
+
+    return {
+      items: items.map((s) => castStoryUsersLight(s)),
+      total,
+      hasMore,
+    };
+  });
+
+const allGroupsItemsSchema = z.object({
+  archived: z.boolean().default(false),
+  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(),
+  groupBy: z.enum(GROUP_KEYS).default("none"),
+  orderBy: z.enum(ORDER_KEYS).default("created"),
+  orderDir: z.enum(ORDER_DIRECTIONS).default("desc"),
+  take: z.number().int().min(1).max(1000).default(100),
+  skip: z.number().int().min(0).default(0),
+  groupCount: z.number().int().min(1).max(50).default(1),
+});
+
+export const listAllGroupsItemsFn = createServerFn({ method: "GET" })
+  .validator(allGroupsItemsSchema)
+  .handler(async ({ data }) => {
+    const request = getRequest();
+    await requireAuth(request);
+
+    const base = buildListWhere(data);
+    const field = ORDER_FIELD[data.orderBy];
+    const dir: "asc" | "desc" = data.orderDir === "asc" ? "asc" : "desc";
+    const orderBy: Prisma.StoryOrderByWithRelationInput = field
+      ? { [field]: dir }
+      : { createdAt: dir };
+
+    const batchTake = data.take * data.groupCount;
+    const items = await prisma.story.findMany({
+      where: base,
+      orderBy,
+      skip: data.skip,
+      take: batchTake,
+      select: STORY_LIST_SELECT_LIGHT,
+    });
+
+    const grouped: Record<string, StoryListRowLight[]> = {};
+    for (const item of items) {
+      const key = deriveGroupKeyFromRow(item, data.groupBy);
+      if (key) (grouped[key] ??= []).push(item);
+    }
+
+    return { grouped: Object.fromEntries(Object.entries(grouped).map(([k, v]) => [k, v.map(castStoryUsersLight)])) };
+  });
+
+function deriveGroupKeyFromRow(
+  row: StoryListRowLight,
+  groupBy: GroupKey,
+): string | null {
+  switch (groupBy) {
+    case "none":
+      return "all";
+    case "state":
+      return row.state ?? null;
+    case "priority":
+      return row.priority ?? null;
+    case "assignee":
+      return row.assignee?.id ?? "unassigned";
+    case "createdBy":
+      return row.createdBy?.id ?? null;
+    case "project":
+      return row.projectId ?? "no-project";
+    default:
+      return null;
+  }
+}
+
+const listGroupsSchema = z.object({
+  archived: z.boolean().default(false),
+  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(),
+  groupBy: z.enum(GROUP_KEYS).default("state"),
+  showEmptyGroups: z.boolean().default(false),
+  parentGroupBy: z.enum(GROUP_KEYS).default("none"),
+  parentGroupKey: z.string().default(""),
+});
+
+const GROUP_BY_FIELD = {
+  state: "state",
+  priority: "priority",
+  assignee: "assigneeId",
+  createdBy: "createdById",
+  project: "projectId",
+} as const satisfies Record<Exclude<GroupKey, "none" | "labels">, Prisma.StoryScalarFieldEnum>;
+
+function deriveGroupKey(groupBy: GroupKey, row: Record<string, unknown>): string | null {
+  switch (groupBy) {
+    case "assignee":
+      return (row.assigneeId as string | null) ?? "unassigned";
+    case "project":
+      return (row.projectId as string | null) ?? "no-project";
+    case "state":
+      return (row.state as string | undefined) ?? null;
+    case "priority":
+      return (row.priority as string | undefined) ?? null;
+    case "createdBy":
+      return (row.createdById as string | undefined) ?? null;
+    default:
+      return null;
+  }
+}
+
+export const listStoryGroupsFn = createServerFn({ method: "GET" })
+  .validator(listGroupsSchema)
+  .handler(async ({ data }) => {
+    const request = getRequest();
+    await requireAuth(request);
+    if (data.groupBy === "none") return { groups: [] };
+
+    const where = buildListWhere(data);
+    if (data.parentGroupBy !== "none" && data.parentGroupKey) {
+      const parentWhere = buildGroupFilter(data.parentGroupBy, data.parentGroupKey);
+      if (Object.keys(parentWhere).length) {
+        where.AND = [
+          ...(Array.isArray(where.AND) ? where.AND : where.AND ? [where.AND] : []),
+          parentWhere,
+        ];
+      }
+    }
+    const keys: string[] = [];
+
+    if (data.showEmptyGroups) {
+      if (data.groupBy === "state") {
+        keys.push(...STORY_STATES.map((s) => s.value));
+      } else if (data.groupBy === "priority") {
+        keys.push(...STORY_PRIORITIES.map((p) => p.value));
+      }
+    }
+
+    if (data.groupBy === "labels") {
+      const noLabelsWhere: Prisma.StoryWhereInput = {
+        ...where,
+        AND: [
+          ...(Array.isArray(where.AND) ? where.AND : where.AND ? [where.AND] : []),
+          { labels: { none: {} } },
+        ],
+      };
+      const [labelRows, noLabels] = await Promise.all([
+        prisma.storyLabel.groupBy({
+          by: ["labelId"],
+          where: { story: where },
+          _count: { _all: true },
+        }),
+        prisma.story.count({ where: noLabelsWhere }),
+      ]);
+      const groups: Array<{ key: string; total: number }> = [];
+      if (noLabels > 0 && !keys.includes("no-labels")) {
+        keys.push("no-labels");
+        groups.push({ key: "no-labels", total: noLabels });
+      }
+      for (const row of labelRows) {
+        const k = row.labelId;
+        if (!keys.includes(k)) {
+          keys.push(k);
+          groups.push({ key: k, total: row._count._all });
+        }
+      }
+      return { groups };
+    }
+
+    const counts = await prisma.story.groupBy({
+      by: [GROUP_BY_FIELD[data.groupBy]],
+      where,
+      _count: { _all: true },
+    });
+    const totalMap = new Map<string, number>();
+    for (const row of counts) {
+      const k = deriveGroupKey(data.groupBy, row as unknown as Record<string, unknown>);
+      if (k) {
+        totalMap.set(k, (row as unknown as { _count: { _all: number } })._count._all);
+        if (!keys.includes(k)) keys.push(k);
+      }
+    }
+    const groups: Array<{ key: string; total: number }> = keys.map((k) => ({ key: k, total: totalMap.get(k) ?? 0 }));
+    return { groups };
+  });

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

@@ -0,0 +1,90 @@
+// 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";
+
+export const addLinkFn = createServerFn({ method: "POST" })
+  .validator(z.object({ storyId: z.string(), url: z.string().url(), title: z.string().optional(), description: z.string().optional() }))
+  .handler(async ({ data }) => {
+    const request = getRequest();
+    const session = await requireAuth(request);
+
+    const link = await prisma.storyLink.create({
+      data: {
+        storyId: data.storyId,
+        url: data.url,
+        title: data.title,
+        description: data.description,
+      },
+    });
+
+    return link;
+  });
+
+export const updateLinkFn = createServerFn({ method: "POST" })
+  .validator(z.object({ linkId: z.string(), url: z.string().url().optional(), title: z.string().optional(), description: z.string().optional() }))
+  .handler(async ({ data }) => {
+    const request = getRequest();
+    const session = await requireAuth(request);
+
+    const link = await prisma.storyLink.update({
+      where: { id: data.linkId },
+      data: {
+        ...(data.url !== undefined && { url: data.url }),
+        ...(data.title !== undefined && { title: data.title }),
+        ...(data.description !== undefined && { description: data.description }),
+      },
+    });
+
+    return link;
+  });
+
+export const removeLinkFn = createServerFn({ method: "POST" })
+  .validator(z.object({ linkId: z.string() }))
+  .handler(async ({ data }) => {
+    const request = getRequest();
+    const session = await requireAuth(request);
+
+    const link = await prisma.storyLink.delete({
+      where: { id: data.linkId },
+    });
+
+    return link;
+  });
+
+export const getLinksFn = createServerFn({ method: "GET" })
+  .validator(z.object({ storyId: z.string() }))
+  .handler(async ({ data }) => {
+    const request = getRequest();
+    const session = await requireAuth(request);
+
+    const links = await prisma.storyLink.findMany({
+      where: { storyId: data.storyId },
+      orderBy: { createdAt: "desc" },
+    });
+
+    return links.map((link) => ({
+      id: link.id,
+      url: link.url,
+      title: link.title,
+      description: link.description,
+    }));
+  });

package/src/server/serverFns/story/story-list-query.ts

@@ -0,0 +1,222 @@
+// 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 { Prisma } from "@allbluecn/database";
+import type { GroupKey } from "@/components/story/display/types";
+import { toValidDate } from "./types";
+
+export function buildListWhere(data: {
+  archived: boolean;
+  state?: string;
+  priority?: string;
+  assigneeId?: string;
+  projectId?: string;
+  labelId?: string;
+  search?: string;
+  filters?: string;
+}): Prisma.StoryWhereInput {
+  const where: Prisma.StoryWhereInput = { archived: data.archived };
+  const andConditions: Prisma.StoryWhereInput[] = [];
+
+  if (data.state) {
+    const states = data.state.split(",").filter(Boolean);
+    if (states.length === 1) {
+      where.state = states[0];
+    } else if (states.length > 1) {
+      where.state = { in: states };
+    }
+  }
+  if (data.priority) {
+    const priorities = data.priority.split(",").filter(Boolean);
+    if (priorities.length === 1) {
+      where.priority = priorities[0];
+    } else if (priorities.length > 1) {
+      where.priority = { in: priorities };
+    }
+  }
+  if (data.assigneeId) {
+    if (data.assigneeId === "__none__") {
+      where.assigneeId = null;
+    } else {
+      const ids = data.assigneeId.split(",").filter(Boolean);
+      if (ids.length === 1) {
+        where.assigneeId = ids[0];
+      } else if (ids.length > 1) {
+        where.assigneeId = { in: ids };
+      }
+    }
+  }
+  if (data.projectId) {
+    where.projectId = data.projectId;
+  }
+  if (data.labelId) {
+    const labelIds = data.labelId.split(",").filter(Boolean);
+    if (labelIds.length === 1) {
+      where.labels = { some: { labelId: labelIds[0] } };
+    } else if (labelIds.length > 1) {
+      where.labels = { some: { labelId: { in: labelIds } } };
+    }
+  }
+  if (data.search) {
+    where.OR = [
+      { name: { contains: data.search, mode: "insensitive" } },
+      { identifier: { contains: data.search, mode: "insensitive" } },
+    ];
+  }
+
+  if (data.filters) {
+    try {
+      const filterConditions = JSON.parse(data.filters) as Array<{ property: string; operator: string; value: string }>;
+      if (Array.isArray(filterConditions)) {
+        for (const fc of filterConditions) {
+          if (fc.property === "state") {
+            const vals = fc.value.split(",").filter(Boolean);
+            if (vals.length > 0) {
+              if (fc.operator === "is_not" || fc.operator === "is_not_any_of") {
+                andConditions.push({ state: { notIn: vals } });
+              } else {
+                andConditions.push({ state: vals.length === 1 ? vals[0] : { in: vals } });
+              }
+            }
+          } else if (fc.property === "priority") {
+            const vals = fc.value.split(",").filter(Boolean);
+            if (vals.length > 0) {
+              if (fc.operator === "is_not" || fc.operator === "is_not_any_of") {
+                andConditions.push({ priority: { notIn: vals } });
+              } else {
+                andConditions.push({ priority: vals.length === 1 ? vals[0] : { in: vals } });
+              }
+            }
+          } else if (fc.property === "assigneeId") {
+            if (fc.operator === "is_empty" || (fc.operator === "is" && !fc.value)) {
+              andConditions.push({ assigneeId: null });
+            } else if (fc.operator === "is_not_empty" || (fc.operator === "is_not" && !fc.value)) {
+              andConditions.push({ assigneeId: { not: null } });
+            } else if (fc.value) {
+              if (fc.operator === "is_not" || fc.operator === "is_not_any_of") {
+                andConditions.push({ assigneeId: { not: fc.value } });
+              } else {
+                andConditions.push({ assigneeId: fc.value });
+              }
+            }
+          } else if (fc.property === "labelId") {
+            const vals = fc.value.split(",").filter(Boolean);
+            if (vals.length > 0) {
+              if (fc.operator === "is_not" || fc.operator === "is_not_any_of") {
+                andConditions.push({ labels: { none: { labelId: { in: vals } } } });
+              } else {
+                andConditions.push({ labels: { some: { labelId: vals.length === 1 ? vals[0] : { in: vals } } } });
+              }
+            } else if (fc.operator === "is_empty") {
+              andConditions.push({ labels: { none: {} } });
+            } else if (fc.operator === "is_not_empty") {
+              andConditions.push({ labels: { some: {} } });
+            }
+          } else if (fc.property === "createdDate" && fc.value) {
+            if (fc.operator === "between") {
+              const parts = fc.value.split(",").filter(Boolean);
+              const d0 = parts[0] ? toValidDate(parts[0]) : null;
+              const d1 = parts[1] ? toValidDate(parts[1]) : null;
+              if (d0) andConditions.push({ createdAt: { gte: d0 } });
+              if (d1) andConditions.push({ createdAt: { lte: d1 } });
+            } else {
+              const d = toValidDate(fc.value);
+              if (!d) continue;
+              if (fc.operator === "before") {
+                andConditions.push({ createdAt: { lt: d } });
+              } else if (fc.operator === "after" || fc.operator === "on_or_after") {
+                andConditions.push({ createdAt: { gte: d } });
+              } else if (fc.operator === "on_or_before") {
+                andConditions.push({ createdAt: { lte: d } });
+              } else if (fc.operator === "is" || fc.operator === "is_not") {
+                const end = new Date(d);
+                end.setDate(end.getDate() + 1);
+                if (fc.operator === "is") {
+                  andConditions.push({ createdAt: { gte: d, lt: end } });
+                } else {
+                  andConditions.push({ createdAt: { lt: d, gte: end } });
+                }
+              }
+            }
+          } else if (fc.property === "targetDate" && fc.value) {
+            if (fc.operator === "between") {
+              const parts = fc.value.split(",").filter(Boolean);
+              const d0 = parts[0] ? toValidDate(parts[0]) : null;
+              const d1 = parts[1] ? toValidDate(parts[1]) : null;
+              if (d0) andConditions.push({ targetDate: { gte: d0 } });
+              if (d1) andConditions.push({ targetDate: { lte: d1 } });
+            } else {
+              const d = toValidDate(fc.value);
+              if (!d) continue;
+              if (fc.operator === "before") {
+                andConditions.push({ targetDate: { lt: d } });
+              } else if (fc.operator === "after" || fc.operator === "on_or_after") {
+                andConditions.push({ targetDate: { gte: d } });
+              } else if (fc.operator === "on_or_before") {
+                andConditions.push({ targetDate: { lte: d } });
+              } else if (fc.operator === "is" || fc.operator === "is_not") {
+                const end = new Date(d);
+                end.setDate(end.getDate() + 1);
+                if (fc.operator === "is") {
+                  andConditions.push({ targetDate: { gte: d, lt: end } });
+                } else {
+                  andConditions.push({ targetDate: { lt: d, gte: end } });
+                }
+              }
+            }
+          } else if (fc.property === "title") {
+            const val = fc.value.trim();
+            if (fc.operator === "is_empty") {
+              andConditions.push({ name: { equals: "" } });
+            } else if (fc.operator === "is_not_empty") {
+              andConditions.push({ name: { not: "" } });
+            } else if (val) {
+              if (fc.operator === "not_contains") {
+                andConditions.push({ name: { not: { contains: val }, mode: "insensitive" } });
+              } else {
+                andConditions.push({ name: { contains: val, mode: "insensitive" } });
+              }
+            }
+          }
+        }
+      }
+    } catch {}
+  }
+
+  if (andConditions.length > 0) {
+    where.AND = andConditions;
+  }
+
+  return where;
+}
+
+const GROUP_FILTERS: Record<Exclude<GroupKey, "none">, (key: string) => Prisma.StoryWhereInput> = {
+  state: (key) => ({ state: key }),
+  priority: (key) => ({ priority: key }),
+  assignee: (key) => (key === "unassigned" ? { assigneeId: null } : { assigneeId: key }),
+  createdBy: (key) => ({ createdById: key }),
+  labels: (key) => (key === "no-labels" ? { labels: { none: {} } } : { labels: { some: { labelId: key } } }),
+  project: (key) =>
+    // no-project 属防御分支：当前 schema projectId 非空必填（内置独立项目兜底），该组实际恒空，
+    // 保留以匹配前端 group-resolver 的 no-project 语义
+    (key === "no-project" ? { projectId: null } as unknown as Prisma.StoryWhereInput : { projectId: key }),
+};
+
+export function buildGroupFilter(groupBy: GroupKey, key: string): Prisma.StoryWhereInput {
+  if (groupBy === "none") return {};
+  return GROUP_FILTERS[groupBy](key);
+}