feat: implement more compatibility checks

This includes relations, references, key fields, collect fields, business objects and enum values

spec/model/implementation/validation-utils.ts

@@ -31,6 +31,17 @@ export function expectToBeValid(component: Validatable) {
     expect(result.hasMessages(), result.toString()).to.be.false;
 }
 
+export function expectNoErrors(component: Validatable) {
+    const result = validate(component);
+    expect(
+        result.hasErrors(),
+        result
+            .getErrors()
+            .map((e) => e.toString())
+            .join('\n'),
+    ).to.be.false;
+}
+
 export function expectSingleError(component: Validatable, errorPart: string) {
     expectSingleMessage(component, errorPart, Severity.ERROR);
 }

spec/project/select-modules-in-sources.spec.ts

@@ -36,7 +36,7 @@ describe('selectModulesInProjectSource', () => {
                         two: String @modules(in: ["module2"])
                         extra1: String @modules(in: ["extra1"])
                         
-                        one: String @modules(in: "module1")
+                        one: String @modules(in: ["module1"])
                     }
 
                     type Two @rootEntity @modules(in: ["module2"]) {
@@ -48,6 +48,25 @@ describe('selectModulesInProjectSource', () => {
                 `);
         });
 
+        it('keeps id: ID @key', () => {
+            // special case because system fields are usually not specified in the source, but id: ID @key needs to stay
+            const result = run(
+                gql`
+                    type Test @rootEntity @modules(in: ["module1", "module2"]) {
+                        id: ID @key
+                        field: String @modules(in: ["module1", "module2"])
+                    }
+                `,
+                ['module1'],
+            );
+            expect(result).to.equal(`
+                    type Test @rootEntity @modules(in: ["module1"]) {
+                        id: ID @key
+                        field: String @modules(in: ["module1"])
+                    }
+                `);
+        });
+
         it('removes the non-selected modules from the modules.json', () => {
             const project = new Project({
                 sources: [
@@ -78,6 +97,26 @@ describe('selectModulesInProjectSource', () => {
                 'module2',
             ]);
         });
+
+        it('works with includeAllFields: true', () => {
+            const result = run(
+                gql`
+                    type Test @rootEntity @modules(in: "module1", includeAllFields: true) {
+                        field: Test @reference(keyField: "keyField")
+                        key: String @key
+                        keyField: String
+                    }
+                `,
+                ['module1'],
+            );
+            expect(result).to.equal(`
+                    type Test @rootEntity @modules(includeAllFields: true, in: ["module1"]) {
+                        field: Test @reference(keyField: "keyField")
+                        key: String @key
+                        keyField: String
+                    }
+                `);
+        });
     });
 
     describe('with removeModuleDeclarations = true', () => {

src/model/compatibility-check/check-enum-type.ts

@@ -0,0 +1,24 @@
+import { EnumType } from '../implementation';
+import { ValidationContext, ValidationMessage } from '../validation';
+import { getRequiredBySuffix } from './describe-module-specification';
+
+export function checkEnumType(
+    typeToCheck: EnumType,
+    baselineType: EnumType,
+    context: ValidationContext,
+) {
+    for (const baselineValue of baselineType.values) {
+        const matchingValue = typeToCheck.values.find((v) => v.value === baselineValue.value);
+        if (!matchingValue) {
+            context.addMessage(
+                ValidationMessage.compatibilityIssue(
+                    `Enum value "${baselineValue.value}" is missing${getRequiredBySuffix(
+                        baselineType,
+                    )}.`,
+                    typeToCheck.nameASTNode,
+                ),
+            );
+            continue;
+        }
+    }
+}