#49 part 3 — PRI brings up the full delivery chain (avc, uni, cvc, ntd)

matt-beanland · matt-beanland · commit 56a687454f4a · 2026-05-23T15:31:23.000+09:30
* PRI single-hop avc/uni via :owns relationship; two-hop cvc/ntd via :owns then assignment
* InheritedCharacteristicViaRelationship extended with then_via: for mixed paths
* 1 new sandboxed test, 1 new show_neo4j exploration test, 54/54 pass
diff --git a/CHANGELOG.md b/CHANGELOG.md
@@ -34,10 +34,11 @@ See [Conventional Commits](Https://conventionalcommits.org) for commit guideline
   * New `cvc_metrics` characteristic on CVC carries `avcs_count` and `avcs_total_bandwidth` aggregated live over assigned AVCs.
   * New `nni_group_metrics` characteristic on NniGroup carries `cvcs_count`/`cvcs_total_bandwidth` (demand), `nnis_count`/`nnis_total_bandwidth` (capacity), and `utilization = cvcs_total_bandwidth / nnis_total_bandwidth`.
 * NBN — NTD brings up assigned UNIs as `unis[]` via the `:port` assignment (issue #49 part 2).
+* NBN — NbnEthernet (PRI) brings up four characteristics surfacing the full delivery chain (issue #49 part 3): `avc` single-hop via the `:avc` owns relationship, `uni` single-hop via the `:uni` owns relationship, `cvc` two-hop via `:avc` then `:cvlan`, and `ntd` two-hop via `:uni` then `:port`. All singular.
 * `BandwidthProfile.downstream/1` — atom-to-Mbps mapping used by the metrics aggregation. CVCs are treated as symmetric capacity in this model (satellite asymmetry ignored).
 
 ### Refactors (continued):
-* `DiffoExample.Calculations.InheritedCharacteristic` renamed to `InheritedCharacteristicViaAssignment`; new sibling `InheritedCharacteristicViaRelationship` traverses `Provider.Relationship` edges (forward source → target). Both calcs accept `singular?:` to unwrap to a single value where graph identity guarantees ≤1 result.
+* `DiffoExample.Calculations.InheritedCharacteristic` renamed to `InheritedCharacteristicViaAssignment`; new sibling `InheritedCharacteristicViaRelationship` traverses `Provider.Relationship` edges (forward source → target). Both calcs accept `singular?:` to unwrap to a single value where graph identity guarantees ≤1 result. `InheritedCharacteristicViaRelationship` also accepts a `then_via:` list of assignment aliases to continue the walk via `AssignmentRelationship` after the relationship hop — covers mixed paths like PRI's `cvc` (relationship + assignment).
 * `ReverseInheritedCharacteristic` extended with a `thing:` filter option, complementing the existing `alias:` filter. Source-side aggregations should prefer `thing:` since it's always set from the pool DSL — see the assignment-direction-asymmetry rationale.
 
 ## [v0.2.2](https://github.com/diffo-dev/diffo/compare/v0.2.1..v0.2.2) (2026-05-21)
diff --git a/lib/diffo_example/calculations/inherited_characteristic_via_relationship.ex b/lib/diffo_example/calculations/inherited_characteristic_via_relationship.ex
@@ -23,10 +23,17 @@ defmodule DiffoExample.Calculations.InheritedCharacteristicViaRelationship do
   ## Options
 
   - `characteristic_module:` *(required)* — the typed characteristic Ash
-    resource on each target (e.g. `NniCharacteristic`). The calc queries
-    this resource by `instance_id` and returns the `.value`.
+    resource on the final source (e.g. `NniCharacteristic`). The calc
+    queries this resource by `instance_id` and returns the `.value`.
   - `type:` *(optional)* — filter relationships by type atom (e.g. `:contains`).
   - `alias:` *(optional)* — filter relationships by alias atom (e.g. `:avc`).
+  - `then_via:` *(optional)* — list of `AssignmentRelationship` aliases to
+    walk **after** the relationship hop. Each step walks back through the
+    target's incoming assignments (`target_id + alias` identity, so each
+    step has cardinality ≤1). Use this for mixed paths — one relationship
+    hop followed by one or more assignment hops — e.g. PRI's `:cvc`
+    bring-up: `:avc` owns relationship, then `:cvlan` assignment back to
+    the CVC.
   - `singular?:` *(optional, default `false`)* — unwrap to a single value
     when the consumer expects a 1-cardinality result (e.g. PRI's `:avc` or
     `:uni` aliased owns-relationship). Declare the calc's return type as
@@ -45,6 +52,13 @@ defmodule DiffoExample.Calculations.InheritedCharacteristicViaRelationship do
       calculate :avc, :map,
                 {DiffoExample.Calculations.InheritedCharacteristicViaRelationship,
                  [alias: :avc, characteristic_module: AvcCharacteristic, singular?: true]}
+
+      # PRI brings up the singular CVC two-hop — :avc owns relationship,
+      # then back via the AVC's incoming :cvlan assignment to the CVC.
+      calculate :cvc, :map,
+                {DiffoExample.Calculations.InheritedCharacteristicViaRelationship,
+                 [alias: :avc, then_via: [:cvlan],
+                  characteristic_module: CvcCharacteristic, singular?: true]}
   """
   use Ash.Resource.Calculation
   require Ash.Query
@@ -57,6 +71,7 @@ defmodule DiffoExample.Calculations.InheritedCharacteristicViaRelationship do
     characteristic_module = Keyword.fetch!(opts, :characteristic_module)
     type_filter = Keyword.get(opts, :type)
     alias_filter = Keyword.get(opts, :alias)
+    then_via = Keyword.get(opts, :then_via, [])
     singular? = Keyword.get(opts, :singular?, false)
 
     Enum.map(records, fn record ->
@@ -66,8 +81,10 @@ defmodule DiffoExample.Calculations.InheritedCharacteristicViaRelationship do
         |> Ash.read!(domain: Diffo.Provider)
         |> Enum.map(& &1.target_id)
 
+      final_ids = walk_assignments(target_ids, then_via)
+
       values =
-        Enum.flat_map(target_ids, fn id ->
+        Enum.flat_map(final_ids, fn id ->
           characteristic_module
           |> Ash.Query.filter_input(instance_id: id)
           |> Ash.Query.load(:value)
@@ -79,6 +96,22 @@ defmodule DiffoExample.Calculations.InheritedCharacteristicViaRelationship do
     end)
   end
 
+  # Walks back through incoming `AssignmentRelationship` records for each
+  # id, following `target_id + alias` (identity, ≤1 source per step).
+  defp walk_assignments(ids, []), do: ids
+
+  defp walk_assignments(ids, [alias_step | rest]) do
+    next_ids =
+      Enum.flat_map(ids, fn id ->
+        Diffo.Provider.AssignmentRelationship
+        |> Ash.Query.filter_input(target_id: id, alias: alias_step)
+        |> Ash.read!(domain: Diffo.Provider)
+        |> Enum.map(& &1.source_id)
+      end)
+
+    walk_assignments(next_ids, rest)
+  end
+
   defp filter_relationships(query, source_id, nil, nil),
     do: Ash.Query.filter_input(query, source_id: source_id)
 
diff --git a/lib/nbn/resources/nbn_ethernet.ex b/lib/nbn/resources/nbn_ethernet.ex
@@ -94,6 +94,60 @@ defmodule DiffoExample.Nbn.NbnEthernet do
     end
   end
 
+  calculations do
+    # The singular AVC this access owns — single-hop via :avc owns relationship.
+    calculate :avc,
+              :map,
+              {DiffoExample.Calculations.InheritedCharacteristicViaRelationship,
+               [
+                 alias: :avc,
+                 characteristic_module: DiffoExample.Nbn.AvcCharacteristic,
+                 singular?: true
+               ]} do
+      public? true
+    end
+
+    # The singular UNI this access owns — single-hop via :uni owns relationship.
+    calculate :uni,
+              :map,
+              {DiffoExample.Calculations.InheritedCharacteristicViaRelationship,
+               [
+                 alias: :uni,
+                 characteristic_module: DiffoExample.Nbn.UniCharacteristic,
+                 singular?: true
+               ]} do
+      public? true
+    end
+
+    # The singular CVC backing this access's AVC — two-hop via :avc owns
+    # relationship, then back via the AVC's incoming :cvlan assignment.
+    calculate :cvc,
+              :map,
+              {DiffoExample.Calculations.InheritedCharacteristicViaRelationship,
+               [
+                 alias: :avc,
+                 then_via: [:cvlan],
+                 characteristic_module: DiffoExample.Nbn.CvcCharacteristic,
+                 singular?: true
+               ]} do
+      public? true
+    end
+
+    # The singular NTD this access's UNI plugs into — two-hop via :uni
+    # owns relationship, then back via the UNI's incoming :port assignment.
+    calculate :ntd,
+              :map,
+              {DiffoExample.Calculations.InheritedCharacteristicViaRelationship,
+               [
+                 alias: :uni,
+                 then_via: [:port],
+                 characteristic_module: DiffoExample.Nbn.NtdCharacteristic,
+                 singular?: true
+               ]} do
+      public? true
+    end
+  end
+
   def identifier() do
     DiffoExample.Nbn.Util.identifier("PRI")
   end
diff --git a/test/nbn/nbn_ethernet_test.exs b/test/nbn/nbn_ethernet_test.exs
@@ -145,6 +145,89 @@ defmodule DiffoExample.Nbn.NbnEthernetTest do
       assert encoding ==
                ~s({"id":"#{access.id}","href":"resourceInventoryManagement/v4/resource/#{access.id}","category":"Network Resource","description":"An NBN Ethernet access comprising a dedicated UNI and AVC","name":"#{access.name}","resourceSpecification":{"id":"f2a4c6e8-1b3d-4f5a-8c7e-9d0b2e4f6a8c","href":"resourceCatalogManagement/v4/resourceSpecification/f2a4c6e8-1b3d-4f5a-8c7e-9d0b2e4f6a8c","name":"nbnEthernet","version":"v1.0.0"},"resourceRelationship":[{"alias":"avc","type":"owns","resource":{"id":"#{avc.id}","href":"resourceInventoryManagement/v4/resource/#{avc.id}"}},{"alias":"uni","type":"owns","resource":{"id\":"#{uni.id}","href":"resourceInventoryManagement/v4/resource/#{uni.id}"}}],"supportingResource":[{"id":"avc","href":"resourceInventoryManagement/v4/resource/#{avc.id}"},{"id\":"uni","href":"resourceInventoryManagement/v4/resource/#{uni.id}"}],"resourceCharacteristic":[{"name":"pri","value":{}}]})
     end
+
+    test "pri brings up avc, uni, cvc, ntd via relationship + assignment chains" do
+      # CVC with cvlan pool, assigned to an AVC
+      {:ok, cvc} = Nbn.build_cvc(%{})
+
+      {:ok, cvc} =
+        Nbn.define_cvc(cvc, %{
+          characteristic_value_updates: [
+            cvc: [svlan: 1, bandwidth: 1000],
+            cvlans: [first: 1, last: 100, assignable_type: "cvlan"]
+          ]
+        })
+
+      # NTD with port pool, assigned to a UNI
+      {:ok, ntd} = Nbn.build_ntd(%{})
+
+      {:ok, ntd} =
+        Nbn.define_ntd(ntd, %{
+          characteristic_value_updates: [
+            ntd: [model: "Sercomm CG4000A", technology: :FTTP],
+            ports: [first: 1, last: 4, assignable_type: "port"]
+          ]
+        })
+
+      # AVC + UNI
+      {:ok, avc} = Nbn.build_avc(%{})
+
+      {:ok, _} =
+        Nbn.define_avc(avc, %{
+          characteristic_value_updates: [avc: [bandwidth_profile: :home_fast]]
+        })
+
+      {:ok, uni} = Nbn.build_uni(%{})
+
+      {:ok, _} =
+        Nbn.define_uni(uni, %{
+          characteristic_value_updates: [
+            uni: [port: 1, encapsulation: "DSCP Mapped", technology: :FTTP]
+          ]
+        })
+
+      # AVC takes a cvlan from CVC; UNI takes a port from NTD. Set explicit
+      # aliases so the inheritance walks (target_id + alias identity)
+      # resolve cleanly.
+      {:ok, _} =
+        Nbn.assign_cvlan(cvc, %{
+          assignment: %Assignment{
+            assignee_id: avc.id,
+            alias: :cvlan,
+            operation: :auto_assign
+          }
+        })
+
+      {:ok, _} =
+        Nbn.assign_port(ntd, %{
+          assignment: %Assignment{
+            assignee_id: uni.id,
+            alias: :port,
+            operation: :auto_assign
+          }
+        })
+
+      # PRI owns the AVC and UNI
+      {:ok, pri} = Nbn.build_nbn_ethernet(%{})
+
+      {:ok, _} =
+        Nbn.relate_nbn_ethernet(pri, %{
+          relationships: [
+            %Relationship{id: avc.id, direction: :forward, type: :owns, alias: :avc},
+            %Relationship{id: uni.id, direction: :forward, type: :owns, alias: :uni}
+          ]
+        })
+
+      {:ok, pri} = Nbn.get_nbn_ethernet_by_id(pri.id, load: [:avc, :uni, :cvc, :ntd])
+
+      # Single-hop via :owns relationship
+      assert %{bandwidth_profile: :home_fast} = pri.avc
+      assert %{port: 1, encapsulation: "DSCP Mapped", technology: :FTTP} = pri.uni
+
+      # Two-hop: :owns relationship then :cvlan / :port assignment
+      assert %{svlan: 1, bandwidth: 1000} = pri.cvc
+      assert %{model: "Sercomm CG4000A", technology: :FTTP} = pri.ntd
+    end
   end
 
   describe "build uni" do
diff --git a/test/nbn/show_neo4j_test.exs b/test/nbn/show_neo4j_test.exs
@@ -170,6 +170,99 @@ defmodule DiffoExample.Nbn.ShowNeo4jTest do
     |> IO.puts()
   end
 
+  test "PRI (NbnEthernet access) with full delivery chain — AVC + UNI + CVC + NTD" do
+    # CVC + cvlan pool
+    {:ok, cvc} = Nbn.build_cvc(%{})
+
+    {:ok, cvc} =
+      Nbn.define_cvc(cvc, %{
+        characteristic_value_updates: [
+          cvc: [svlan: 1, bandwidth: 1000],
+          cvlans: [first: 1, last: 100, assignable_type: "cvlan"]
+        ]
+      })
+
+    # NTD + port pool
+    {:ok, ntd} = Nbn.build_ntd(%{})
+
+    {:ok, ntd} =
+      Nbn.define_ntd(ntd, %{
+        characteristic_value_updates: [
+          ntd: [model: "Sercomm CG4000A", technology: :FTTP],
+          ports: [first: 1, last: 4, assignable_type: "port"]
+        ]
+      })
+
+    # AVC + UNI
+    {:ok, avc} = Nbn.build_avc(%{})
+
+    {:ok, _} =
+      Nbn.define_avc(avc, %{
+        characteristic_value_updates: [avc: [bandwidth_profile: :home_fast]]
+      })
+
+    {:ok, uni} = Nbn.build_uni(%{})
+
+    {:ok, _} =
+      Nbn.define_uni(uni, %{
+        characteristic_value_updates: [
+          uni: [port: 1, encapsulation: "DSCP Mapped", technology: :FTTP]
+        ]
+      })
+
+    {:ok, _} =
+      Nbn.assign_cvlan(cvc, %{
+        assignment: %Assignment{
+          assignee_id: avc.id,
+          alias: :cvlan,
+          operation: :auto_assign
+        }
+      })
+
+    {:ok, _} =
+      Nbn.assign_port(ntd, %{
+        assignment: %Assignment{
+          assignee_id: uni.id,
+          alias: :port,
+          operation: :auto_assign
+        }
+      })
+
+    # PRI owns AVC and UNI
+    {:ok, pri} = Nbn.build_nbn_ethernet(%{})
+
+    {:ok, _} =
+      Nbn.relate_nbn_ethernet(pri, %{
+        relationships: [
+          %Relationship{id: avc.id, direction: :forward, type: :owns, alias: :avc},
+          %Relationship{id: uni.id, direction: :forward, type: :owns, alias: :uni}
+        ]
+      })
+
+    {:ok, pri} = Nbn.get_nbn_ethernet_by_id(pri.id, load: [:avc, :uni, :cvc, :ntd])
+
+    IO.puts("\n========== PRI.avc (single-hop via :avc owns) ==========")
+    IO.inspect(pri.avc, label: "pri.avc")
+
+    IO.puts("\n========== PRI.uni (single-hop via :uni owns) ==========")
+    IO.inspect(pri.uni, label: "pri.uni")
+
+    IO.puts("\n========== PRI.cvc (two-hop via :avc owns + :cvlan assignment) ==========")
+    IO.inspect(pri.cvc, label: "pri.cvc")
+
+    IO.puts("\n========== PRI.ntd (two-hop via :uni owns + :port assignment) ==========")
+    IO.inspect(pri.ntd, label: "pri.ntd")
+
+    IO.puts("\n========== PRI (TMF JSON) ==========")
+
+    pri
+    |> Jason.encode!()
+    |> Diffo.Util.summarise_dates()
+    |> Jason.decode!()
+    |> Jason.encode!(pretty: true)
+    |> IO.puts()
+  end
+
   test "NTD with assigned UNIs" do
     {:ok, ntd} = Nbn.build_ntd(%{})
 
