feat: validate that the @key field is always included in all modules

Restricting the key field would mean references sometimes do not work

Author: Yogu

spec/schema/ast-validation-modules/modules-validator.spec.ts

@@ -303,6 +303,53 @@ describe('modules validator', () => {
         });
     });
 
+    describe('on key fields', () => {
+        it('accepts @modules(includeAllFields: true)', () => {
+            assertValidatorAcceptsAndDoesNotWarn(
+                `
+                    type Foo @rootEntity @modules(in: ["module1", "module2"], includeAllFields: true) {
+                        foo: String @key
+                    }
+                `,
+                { withModuleDefinitions: true },
+            );
+        });
+
+        it('accepts @modules(all: true)', () => {
+            assertValidatorAcceptsAndDoesNotWarn(
+                `
+                    type Foo @rootEntity @modules(in: ["module1", "module2"]) {
+                        foo: String @key @modules(all: true)
+                    }
+                `,
+                { withModuleDefinitions: true },
+            );
+        });
+
+        it('accepts explicitly listing exactly the modules from the type', () => {
+            assertValidatorAcceptsAndDoesNotWarn(
+                `
+                    type Foo @rootEntity @modules(in: ["module1", "module2 & module3"]) {
+                        foo: String @key @modules(in: ["module1", "module2 & module3"])
+                    }
+                `,
+                { withModuleDefinitions: true },
+            );
+        });
+
+        it('rejects if the key field is restricted more than the type', () => {
+            assertValidatorRejects(
+                `
+                    type Foo @rootEntity @modules(in: ["module1"]) {
+                        foo: String @key @modules(in: ["module2"])
+                    }
+                `,
+                'Key fields must always be included in all modules of their declaring type. Set @modules(all: true). (Type "Foo" is included in module "module1", but the key field is not.)',
+                { withModuleDefinitions: true },
+            );
+        });
+    });
+
     describe('expressions', () => {
         it('accepts a single module', () => {
             assertValidatorAcceptsAndDoesNotWarn(

src/model/implementation/field.ts

@@ -403,6 +403,7 @@ export class Field implements ModelComponent {
         this.validateFlexSearch(context);
         this.validateAccessField(context);
         this.validateModulesDirective(context);
+        this.validateModulesOfKeyField(context);
         this.validateModuleConsistency(context);
     }
 
@@ -2000,6 +2001,35 @@ export class Field implements ModelComponent {
         this.moduleSpecification.validate(context);
     }
 
+    /**
+     * Checks the combination of @key and modules
+     */
+    private validateModulesOfKeyField(context: ValidationContext) {
+        if (!this.isKeyField || !this.moduleSpecification || this.moduleSpecification.all) {
+            return;
+        }
+
+        // we could just disallow specifying modules altogether, but that might be unexpected
+        // we make sure to suggest the sensible thing - setting all: true - in the message though.
+        const missingClauses =
+            this.declaringType.effectiveModuleSpecification.orCombinedClauses.filter(
+                (clause) =>
+                    !this.effectiveModuleSpecification.includedIn(clause.andCombinedModules),
+            );
+        if (missingClauses.length) {
+            const desc = describeModuleSpecification(
+                new EffectiveModuleSpecification({ orCombinedClauses: missingClauses }),
+                { preposition: 'in' },
+            );
+            context.addMessage(
+                ValidationMessage.error(
+                    `Key fields must always be included in all modules of their declaring type. Set @modules(all: true). (Type "${this.declaringType.name}" is included ${desc}, but the key field is not.)`,
+                    this.input.typeNameAST || this.astNode,
+                ),
+            );
+        }
+    }
+
     /**
      * Checks that this field is only included in modules that also include all prerequisites (type, collect path...)
      */