chore(repo): initialize planarchy workspace

2026-03-14 14:31:09 +01:00
commit dd55d0e78b
769 changed files with 166461 additions and 0 deletions
@@ -0,0 +1,128 @@
+import { CreateOrgUnitSchema, UpdateOrgUnitSchema } from "@planarchy/shared";
+import { TRPCError } from "@trpc/server";
+import { z } from "zod";
+import { adminProcedure, createTRPCRouter, protectedProcedure } from "../trpc.js";
+
+import type { OrgUnitTree } from "@planarchy/shared";
+
+interface FlatOrgUnit {
+  id: string;
+  name: string;
+  shortName: string | null;
+  level: number;
+  parentId: string | null;
+  sortOrder: number;
+  isActive: boolean;
+  createdAt: Date;
+  updatedAt: Date;
+}
+
+function buildTree(flatItems: FlatOrgUnit[], parentId: string | null = null): OrgUnitTree[] {
+  return flatItems
+    .filter((item) => item.parentId === parentId)
+    .sort((a, b) => a.sortOrder - b.sortOrder || a.name.localeCompare(b.name))
+    .map((item) => ({
+      ...item,
+      children: buildTree(flatItems, item.id),
+    }));
+}
+
+export const orgUnitRouter = createTRPCRouter({
+  list: protectedProcedure
+    .input(
+      z.object({
+        level: z.number().int().min(5).max(7).optional(),
+        parentId: z.string().optional(),
+        isActive: z.boolean().optional(),
+      }).optional(),
+    )
+    .query(async ({ ctx, input }) => {
+      return ctx.db.orgUnit.findMany({
+        where: {
+          ...(input?.level !== undefined ? { level: input.level } : {}),
+          ...(input?.parentId !== undefined ? { parentId: input.parentId } : {}),
+          ...(input?.isActive !== undefined ? { isActive: input.isActive } : {}),
+        },
+        orderBy: [{ level: "asc" }, { sortOrder: "asc" }, { name: "asc" }],
+      });
+    }),
+
+  getTree: protectedProcedure
+    .input(z.object({ isActive: z.boolean().optional() }).optional())
+    .query(async ({ ctx, input }) => {
+      const all = await ctx.db.orgUnit.findMany({
+        where: {
+          ...(input?.isActive !== undefined ? { isActive: input.isActive } : {}),
+        },
+        orderBy: [{ sortOrder: "asc" }, { name: "asc" }],
+      });
+      return buildTree(all);
+    }),
+
+  getById: protectedProcedure
+    .input(z.object({ id: z.string() }))
+    .query(async ({ ctx, input }) => {
+      const unit = await ctx.db.orgUnit.findUnique({
+        where: { id: input.id },
+        include: {
+          parent: true,
+          children: { orderBy: { sortOrder: "asc" } },
+          _count: { select: { resources: true } },
+        },
+      });
+      if (!unit) throw new TRPCError({ code: "NOT_FOUND", message: "Org unit not found" });
+      return unit;
+    }),
+
+  create: adminProcedure
+    .input(CreateOrgUnitSchema)
+    .mutation(async ({ ctx, input }) => {
+      if (input.parentId) {
+        const parent = await ctx.db.orgUnit.findUnique({ where: { id: input.parentId } });
+        if (!parent) throw new TRPCError({ code: "NOT_FOUND", message: "Parent org unit not found" });
+        if (parent.level >= input.level) {
+          throw new TRPCError({
+            code: "BAD_REQUEST",
+            message: `Child level (${input.level}) must be greater than parent level (${parent.level})`,
+          });
+        }
+      }
+
+      return ctx.db.orgUnit.create({
+        data: {
+          name: input.name,
+          ...(input.shortName !== undefined ? { shortName: input.shortName } : {}),
+          level: input.level,
+          ...(input.parentId ? { parentId: input.parentId } : {}),
+          sortOrder: input.sortOrder,
+        },
+      });
+    }),
+
+  update: adminProcedure
+    .input(z.object({ id: z.string(), data: UpdateOrgUnitSchema }))
+    .mutation(async ({ ctx, input }) => {
+      const existing = await ctx.db.orgUnit.findUnique({ where: { id: input.id } });
+      if (!existing) throw new TRPCError({ code: "NOT_FOUND", message: "Org unit not found" });
+
+      return ctx.db.orgUnit.update({
+        where: { id: input.id },
+        data: {
+          ...(input.data.name !== undefined ? { name: input.data.name } : {}),
+          ...(input.data.shortName !== undefined ? { shortName: input.data.shortName } : {}),
+          ...(input.data.sortOrder !== undefined ? { sortOrder: input.data.sortOrder } : {}),
+          ...(input.data.isActive !== undefined ? { isActive: input.data.isActive } : {}),
+          ...(input.data.parentId !== undefined ? { parentId: input.data.parentId } : {}),
+        },
+      });
+    }),
+
+  deactivate: adminProcedure
+    .input(z.object({ id: z.string() }))
+    .mutation(async ({ ctx, input }) => {
+      return ctx.db.orgUnit.update({
+        where: { id: input.id },
+        data: { isActive: false },
+      });
+    }),
+});