Atomic reparent RPCs + naming normalization for fleet hierarchy

client/src/protoFleet/api/buildings.ts

@@ -68,13 +68,20 @@ interface DeleteBuildingProps {
   onFinally?: () => void;
 }
 
-interface AssignRackToBuildingProps {
+// RackPlacementInput is one rack's slot in an AssignRacksToBuilding
+// batch. aisleIndex + positionInAisle must be paired (both set or both
+// unset); the server rejects half-set inputs.
+export interface RackPlacementInput {
   rackId: bigint;
-  // Unset = unassign from any building.
-  buildingId?: bigint;
-  // Optional grid cell. Must be paired.
   aisleIndex?: number;
   positionInAisle?: number;
+}
+
+interface AssignRacksToBuildingProps {
+  // Bulk-friendly. Pass a single-element array for the singular case.
+  racks: RackPlacementInput[];
+  // Unset = unassign every rack in the batch from any building.
+  targetBuildingId?: bigint;
   signal?: AbortSignal;
   onSuccess?: (siteReassignedDeviceCount: bigint) => void;
   onError?: (message: string) => void;
@@ -353,29 +360,17 @@ const useBuildings = () => {
     [handleAuthErrors],
   );
 
-  // assignRackToBuilding wraps the dedicated rack-positioning RPC.
-  // Unset `buildingId` unassigns the rack; passing both `aisleIndex`
-  // and `positionInAisle` positions the rack at that grid cell.
-  // Passing one without the other is rejected by the server; the
-  // wrapper preserves the failure surface so callers can react.
-  const assignRackToBuilding = useCallback(
-    async ({
-      rackId,
-      buildingId,
-      aisleIndex,
-      positionInAisle,
-      signal,
-      onSuccess,
-      onError,
-      onFinally,
-    }: AssignRackToBuildingProps) => {
+  // assignRacksToBuilding wraps the bulk rack-positioning RPC.
+  // Unset `targetBuildingId` unassigns every rack in the batch;
+  // each rack's `aisleIndex` + `positionInAisle` must be paired.
+  // The server rejects half-set inputs and out-of-bounds positions.
+  const assignRacksToBuilding = useCallback(
+    async ({ racks, targetBuildingId, signal, onSuccess, onError, onFinally }: AssignRacksToBuildingProps) => {
       try {
-        const response = await buildingsClient.assignRackToBuilding(
+        const response = await buildingsClient.assignRacksToBuilding(
           {
-            rackId,
-            buildingId,
-            aisleIndex,
-            positionInAisle,
+            racks,
+            targetBuildingId,
           },
           { signal },
         );
@@ -404,7 +399,7 @@ const useBuildings = () => {
     createBuilding,
     updateBuilding,
     deleteBuilding,
-    assignRackToBuilding,
+    assignRacksToBuilding,
   };
 };
 

client/src/protoFleet/api/sites.ts

@@ -114,7 +114,7 @@ interface DeleteSiteProps {
   onFinally?: () => void;
 }
 
-interface ReassignDevicesToSiteProps {
+interface AssignDevicesToSiteProps {
   // Unset routes the devices to the "Unassigned" bucket; the create flow
   // always supplies a target so this is typically set in practice.
   targetSiteId?: bigint;
@@ -128,16 +128,30 @@ interface ReassignDevicesToSiteProps {
   onFinally?: () => void;
 }
 
-interface AssignBuildingToSiteProps {
-  buildingId: bigint;
-  // Unset moves the building to "Unassigned".
+interface AssignBuildingsToSiteProps {
+  // Bulk-friendly. Pass a single-element array for the singular case.
+  buildingIds: bigint[];
+  // Unset moves the buildings to "Unassigned".
   targetSiteId?: bigint;
   signal?: AbortSignal;
   onSuccess?: (reassignedRackCount: bigint, reassignedDeviceCount: bigint) => void;
   onError?: (message: string) => void;
   onFinally?: () => void;
 }
 
+interface AssignRacksToSiteProps {
+  // Bulk-friendly. Pass a single-element array for the singular case.
+  rackIds: bigint[];
+  // Unset moves the racks to "Unassigned".
+  targetSiteId?: bigint;
+  signal?: AbortSignal;
+  // onSuccess args: device cascade count, count of racks whose
+  // building was auto-cleared because the move crossed sites.
+  onSuccess?: (reassignedDeviceCount: bigint, clearedBuildingCount: bigint) => void;
+  onError?: (message: string) => void;
+  onFinally?: () => void;
+}
+
 const useSites = () => {
   const { handleAuthErrors } = useAuthErrors();
 
@@ -267,10 +281,10 @@ const useSites = () => {
     [handleAuthErrors],
   );
 
-  const reassignDevicesToSite = useCallback(
-    async ({ targetSiteId, deviceIdentifiers, signal, onSuccess, onError, onFinally }: ReassignDevicesToSiteProps) => {
+  const assignDevicesToSite = useCallback(
+    async ({ targetSiteId, deviceIdentifiers, signal, onSuccess, onError, onFinally }: AssignDevicesToSiteProps) => {
       try {
-        const response = await sitesClient.reassignDevicesToSite(
+        const response = await sitesClient.assignDevicesToSite(
           {
             targetSiteId,
             deviceIdentifiers,
@@ -298,12 +312,12 @@ const useSites = () => {
     [handleAuthErrors],
   );
 
-  const assignBuildingToSite = useCallback(
-    async ({ buildingId, targetSiteId, signal, onSuccess, onError, onFinally }: AssignBuildingToSiteProps) => {
+  const assignBuildingsToSite = useCallback(
+    async ({ buildingIds, targetSiteId, signal, onSuccess, onError, onFinally }: AssignBuildingsToSiteProps) => {
       try {
-        const response = await sitesClient.assignBuildingToSite(
+        const response = await sitesClient.assignBuildingsToSite(
           {
-            buildingId,
+            buildingIds,
             targetSiteId,
           },
           { signal },
@@ -325,7 +339,42 @@ const useSites = () => {
     [handleAuthErrors],
   );
 
-  return { listSites, createSite, updateSite, deleteSite, reassignDevicesToSite, assignBuildingToSite };
+  const assignRacksToSite = useCallback(
+    async ({ rackIds, targetSiteId, signal, onSuccess, onError, onFinally }: AssignRacksToSiteProps) => {
+      try {
+        const response = await sitesClient.assignRacksToSite(
+          {
+            rackIds,
+            targetSiteId,
+          },
+          { signal },
+        );
+        if (signal?.aborted) return;
+        onSuccess?.(response.reassignedDeviceCount, response.clearedBuildingCount);
+      } catch (err) {
+        if (signal?.aborted) return;
+        handleAuthErrors({
+          error: err,
+          onError: (error) => {
+            onError?.(getErrorMessage(error));
+          },
+        });
+      } finally {
+        onFinally?.();
+      }
+    },
+    [handleAuthErrors],
+  );
+
+  return {
+    listSites,
+    createSite,
+    updateSite,
+    deleteSite,
+    assignDevicesToSite,
+    assignBuildingsToSite,
+    assignRacksToSite,
+  };
 };
 
 export { useSites };

client/src/protoFleet/api/useDeviceSets.ts

@@ -165,6 +165,16 @@ interface ClearRackSlotPositionProps {
   onFinally?: () => void;
 }
 
+interface AssignDevicesToRackProps {
+  // Unset clears rack membership without re-assigning (site/building
+  // stay intact).
+  targetRackId?: bigint;
+  deviceIdentifiers: string[];
+  onSuccess?: (assignedCount: bigint, siteReassignedCount: bigint, removedCount: bigint) => void;
+  onError?: (message: string) => void;
+  onFinally?: () => void;
+}
+
 interface SaveRackProps {
   deviceSetId?: bigint;
   label: string;
@@ -601,6 +611,33 @@ const useDeviceSets = () => {
     [handleAuthErrors],
   );
 
+  // assignDevicesToRack wraps the atomic rack-reassignment RPC.
+  // Replaces the old client-side remove + add orchestration so a
+  // server error / network blip between the two calls can't orphan
+  // miners from rack assignment (issue #420). Pass targetRackId
+  // unset to clear rack membership without re-assigning.
+  const assignDevicesToRack = useCallback(
+    async ({ targetRackId, deviceIdentifiers, onSuccess, onError, onFinally }: AssignDevicesToRackProps) => {
+      try {
+        const response = await deviceSetClient.assignDevicesToRack({
+          targetRackId,
+          deviceIdentifiers,
+        });
+        onSuccess?.(response.assignedCount, response.siteReassignedCount, response.removedCount);
+      } catch (err) {
+        handleAuthErrors({
+          error: err,
+          onError: () => {
+            onError?.(getErrorMessage(err));
+          },
+        });
+      } finally {
+        onFinally?.();
+      }
+    },
+    [handleAuthErrors],
+  );
+
   const removeDevicesFromDeviceSet = useCallback(
     async ({
       deviceSetId,
@@ -848,6 +885,7 @@ const useDeviceSets = () => {
     listGroupMembers,
     getDeviceSetStats,
     addDevicesToDeviceSet,
+    assignDevicesToRack,
     removeDevicesFromDeviceSet,
     getRackSlots,
     setRackSlotPosition,

client/src/protoFleet/features/buildings/components/BuildingModals/BuildingModals.test.tsx

@@ -21,7 +21,7 @@ const mockApi = {
   createBuilding: vi.fn(),
   updateBuilding: vi.fn(),
   deleteBuilding: vi.fn(),
-  assignRackToBuilding: vi.fn(),
+  assignRacksToBuilding: vi.fn(),
 };
 vi.mock("@/protoFleet/api/buildings", async () => {
   const actual = await vi.importActual<typeof import("@/protoFleet/api/buildings")>("@/protoFleet/api/buildings");