fix(loader): #368 — rule (d)'s message names both legal homes; correct rule (e)'s scope note

Two small cross-port corrections, identical in TypeScript, Python, C# and Java.

M7 — rule (d) rejected @sourceRefField with "but is not a M:N relationship.", which
reads as "this attribute is never allowed here" now that @Cardinality: "one" is a
legal home for it (the whole point of this branch). The message now names both:
"...but is neither a M:N relationship (requires @through with @Cardinality: "many")
nor a @Cardinality: "one" relationship." Wording is byte-identical across the four
ports.

M6 — rule (e)'s header comment still justified itself against a rule (d) that was
"own-scoped" ("so own-scoping there is correct"). Rule (d) stopped being own-scoped
in this same branch: it walks the effective relationship set and dedupes by node
identity, reporting against the declaring entity. The comment now says what actually
differs — the SUBJECT of each pass, not which relationships it can see.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Lfd8nat1WcSpXffd8YetiC

Author: dmealing

server/csharp/MetaObjects/Loader/ValidationPasses.cs

@@ -3202,7 +3202,9 @@ public static IReadOnlyList<MetaError> ValidateRelationships(MetaData root)
                     if (hasSourceRefField && !isCardinalityOne)
                     {
                         errors.Add(new MetaError(
-                            $"relationship \"{declaringEntity.Name}.{rel.Name}\" sets @{RELATIONSHIP_ATTR_SOURCE_REF_FIELD} but is not a M:N relationship.",
+                            $"relationship \"{declaringEntity.Name}.{rel.Name}\" sets @{RELATIONSHIP_ATTR_SOURCE_REF_FIELD} but is neither a M:N " +
+                            $"relationship (requires @{RELATIONSHIP_ATTR_THROUGH} with @{RELATIONSHIP_ATTR_CARDINALITY}: \"{CARDINALITY_MANY}\") " +
+                            $"nor a @{RELATIONSHIP_ATTR_CARDINALITY}: \"{CARDINALITY_ONE}\" relationship.",
                             ErrorCode.ERR_INVALID_RELATIONSHIP,
                             Envelope: rel.Source));
                     }
@@ -3306,9 +3308,13 @@ public static IReadOnlyList<MetaError> ValidateRelationships(MetaData root)
     // above) — same deferred-resolution timing (after all files load + extends
     // resolution).
     //
-    // Scope differs deliberately from rule (d): rule (d) validates attrs that
-    // travel with the relationship's OWN declaration (@through/@symmetric/
-    // @sourceRefField), so own-scoping there is correct — those attrs don't
+    // Scope differs deliberately from rule (d) — in SUBJECT, not in which
+    // relationships each pass walks (both walk the EFFECTIVE set; rule (d) is
+    // no longer own-scoped, or an M:N declaration reached only via extends
+    // would go unchecked). Rule (d) validates attrs that travel with the
+    // relationship's OWN declaration (@through/@symmetric/@sourceRefField), so
+    // it checks each declaration EXACTLY ONCE — deduped by node identity, and
+    // reported against the entity that declares it — because those attrs don't
     // change meaning depending on who inherits the relationship. Rule (e)
     // instead validates whether THIS entity's reference set resolves the
     // relationship uniquely, which is a property of the EFFECTIVE entity, not of

server/java/metadata/src/main/java/com/metaobjects/loader/ValidationPhase.java

@@ -1819,7 +1819,12 @@ private static void validateRelationshipM2MNode(MetaRoot root, MetaObject obj,
                     ErrorMessageConstants.ERR_INVALID_RELATIONSHIP
                         + ": relationship \"" + declaringEntity.getShortName() + "." + rel.getShortName()
                         + "\" sets @" + MetaRelationship.ATTR_SOURCE_REF_FIELD
-                        + " but is not a M:N relationship.",
+                        + " but is neither a M:N relationship (requires @"
+                        + MetaRelationship.ATTR_THROUGH + " with @"
+                        + MetaRelationship.ATTR_CARDINALITY + ": \""
+                        + MetaRelationship.CARDINALITY_MANY + "\") nor a @"
+                        + MetaRelationship.ATTR_CARDINALITY + ": \""
+                        + MetaRelationship.CARDINALITY_ONE + "\" relationship.",
                     ErrorCode.ERR_INVALID_RELATIONSHIP, rel.getSource()));
             }
             if (symmetric) {
@@ -1926,9 +1931,13 @@ private static void validateRelationshipM2MNode(MetaRoot root, MetaObject obj,
     // above) — same deferred-resolution timing (after all files load + extends
     // resolution).
     //
-    // Scope differs deliberately from rule (d): rule (d) validates attrs that
-    // travel with the relationship's OWN declaration (@through/@symmetric/
-    // @sourceRefField), so own-scoping there is correct — those attrs don't
+    // Scope differs deliberately from rule (d) — in SUBJECT, not in which
+    // relationships each pass walks (both walk the EFFECTIVE set; rule (d) is
+    // no longer own-scoped, or an M:N declaration reached only via extends
+    // would go unchecked). Rule (d) validates attrs that travel with the
+    // relationship's OWN declaration (@through/@symmetric/@sourceRefField), so
+    // it checks each declaration EXACTLY ONCE — deduped by node identity, and
+    // reported against the entity that declares it — because those attrs don't
     // change meaning depending on who inherits the relationship. Rule (e)
     // instead validates whether THIS entity's reference set resolves the
     // relationship uniquely, which is a property of the EFFECTIVE entity, not of

server/java/metadata/src/test/java/com/metaobjects/relationship/Issue368RelationshipReferenceValidationTest.java

@@ -224,7 +224,11 @@ public void sourceRefFieldOnAbsentCardinalityStillErrors() {
         assertHasError(outcome, ErrorCode.ERR_INVALID_RELATIONSHIP);
         assertTrue(outcome.joinedMessages(), outcome.joinedMessages().contains("Week.program"));
         assertTrue(outcome.joinedMessages(), outcome.joinedMessages()
-            .contains("sets @sourceRefField but is not a M:N relationship"));
+            .contains("sets @sourceRefField but is neither a M:N relationship"));
+        // The message names BOTH legal homes for the attribute -- M:N and
+        // @cardinality: "one" -- so it can't read as "never allowed here".
+        assertTrue(outcome.joinedMessages(), outcome.joinedMessages()
+            .contains("nor a @cardinality: \"one\" relationship"));
     }
 
     @Test

server/python/src/metaobjects/loader/validation_passes.py

@@ -2698,7 +2698,10 @@ def _validate_relationships(root: MetaData, errors: list[MetaError]) -> None:
                 if has_source_ref_field and not is_cardinality_one:
                     errors.append(MetaError(
                         f'relationship "{declaring_entity.name}.{rel.name}" sets '
-                        f'@{RELATIONSHIP_ATTR_SOURCE_REF_FIELD} but is not a M:N relationship.',
+                        f'@{RELATIONSHIP_ATTR_SOURCE_REF_FIELD} but is neither a M:N '
+                        f'relationship (requires @{RELATIONSHIP_ATTR_THROUGH} with '
+                        f'@{RELATIONSHIP_ATTR_CARDINALITY}: "{CARDINALITY_MANY}") nor a '
+                        f'@{RELATIONSHIP_ATTR_CARDINALITY}: "{CARDINALITY_ONE}" relationship.',
                         ErrorCode.ERR_INVALID_RELATIONSHIP,
                         envelope=rel.source,
                     ))
@@ -2807,9 +2810,13 @@ def _validate_relationships(root: MetaData, errors: list[MetaError]) -> None:
 # above) — same deferred-resolution timing (after all files load + extends
 # resolution).
 #
-# Scope differs deliberately from rule (d): rule (d) validates attrs that
-# travel with the relationship's OWN declaration (@through/@symmetric/
-# @sourceRefField), so own-scoping there is correct — those attrs don't
+# Scope differs deliberately from rule (d) — in SUBJECT, not in which
+# relationships each pass walks (both walk the EFFECTIVE set; rule (d) is
+# no longer own-scoped, or an M:N declaration reached only via extends
+# would go unchecked). Rule (d) validates attrs that travel with the
+# relationship's OWN declaration (@through/@symmetric/@sourceRefField), so
+# it checks each declaration EXACTLY ONCE — deduped by node identity, and
+# reported against the entity that declares it — because those attrs don't
 # change meaning depending on who inherits the relationship. Rule (e)
 # instead validates whether THIS entity's reference set resolves the
 # relationship uniquely, which is a property of the EFFECTIVE entity, not of

server/typescript/packages/metadata/src/loader/validation-passes.ts

@@ -2058,7 +2058,9 @@ export function validateRelationships(root: MetaData): ParseError[] {
         if (hasSourceRefField && cardinality !== CARDINALITY_ONE) {
           errors.push(
             new ParseError(
-              `relationship "${declaringEntity.name}.${rel.name}" sets @${RELATIONSHIP_ATTR_SOURCE_REF_FIELD} but is not a M:N relationship.`,
+              `relationship "${declaringEntity.name}.${rel.name}" sets @${RELATIONSHIP_ATTR_SOURCE_REF_FIELD} but is neither a M:N ` +
+                `relationship (requires @${RELATIONSHIP_ATTR_THROUGH} with @${RELATIONSHIP_ATTR_CARDINALITY}: "${CARDINALITY_MANY}") ` +
+                `nor a @${RELATIONSHIP_ATTR_CARDINALITY}: "${CARDINALITY_ONE}" relationship.`,
               { code: "ERR_INVALID_RELATIONSHIP", source: rel.source },
             ),
           );
@@ -2168,9 +2170,13 @@ export function validateRelationships(root: MetaData): ParseError[] {
 // above) — same deferred-resolution timing (after all files load + extends
 // resolution).
 //
-// Scope differs deliberately from rule (d): rule (d) validates attrs that
-// travel with the relationship's OWN declaration (@through/@symmetric/
-// @sourceRefField), so own-scoping there is correct — those attrs don't
+// Scope differs deliberately from rule (d) — in SUBJECT, not in which
+// relationships each pass walks (both walk the EFFECTIVE set; rule (d) is
+// no longer own-scoped, or an M:N declaration reached only via extends
+// would go unchecked). Rule (d) validates attrs that travel with the
+// relationship's OWN declaration (@through/@symmetric/@sourceRefField), so
+// it checks each declaration EXACTLY ONCE — deduped by node identity, and
+// reported against the entity that declares it — because those attrs don't
 // change meaning depending on who inherits the relationship. Rule (e)
 // instead validates whether THIS entity's reference set resolves the
 // relationship uniquely, which is a property of the EFFECTIVE entity, not of