@theguild/federation-composition 0.10.1 → 0.11.0-alpha-20240315131906-9fcd4e6

package/README.md

@@ -179,31 +179,18 @@ Your feedback and bug reports are welcome and appreciated.
 - ✅ `REQUIRES_DIRECTIVE_IN_FIELDS_ARG`
 - ✅ `TYPE_DEFINITION_INVALID`
 - ✅ `OVERRIDE_COLLISION_WITH_ANOTHER_DIRECTIVE`
+- ✅ `INTERFACE_OBJECT_USAGE_ERROR`
+- ✅ `REQUIRED_INACCESSIBLE`
+- ✅ `SATISFIABILITY_ERROR`
 
 ### TODOs
 
-- [ ] `INTERFACE_OBJECT_USAGE_ERROR`
 - [ ] `INTERFACE_FIELD_NO_IMPLEM`
-- [ ] `SATISFIABILITY_ERROR`
 - [ ] `DISALLOWED_INACCESSIBLE`
-- [ ] `DOWNSTREAM_SERVICE_ERROR`
 - [ ] `EXTERNAL_ARGUMENT_DEFAULT_MISMATCH`
 - [ ] `EXTERNAL_ARGUMENT_TYPE_MISMATCH`
 - [ ] `EXTERNAL_COLLISION_WITH_ANOTHER_DIRECTIVE`
 - [ ] `IMPLEMENTED_BY_INACCESSIBLE`
-- [ ] `INVALID_FEDERATION_SUPERGRAPH`
 - [ ] `LINK_IMPORT_NAME_MISMATCH`
-- [ ] `REQUIRED_INACCESSIBLE`
-- [ ] `SHAREABLE_HAS_MISMATCHED_RUNTIME_TYPES`
-- [ ] `UNSUPPORTED_FEATURE`
 - [ ] `UNSUPPORTED_LINKED_FEATURE`
 - [ ] `TYPE_WITH_ONLY_UNUSED_EXTERNAL`
-- [ ] `SATISFIABILITY_ERROR` - deeply nested key fields
-- [ ] `SATISFIABILITY_ERROR` - fragments in keys
-- [ ] `SATISFIABILITY_ERROR` - support interfaces... (kill me)
-- [ ] `SATISFIABILITY_ERROR` - @require - check if fields defined by @require can be resolved by
-      current subgraph or by moving to other subgraphs.
-- [ ] `SATISFIABILITY_ERROR` - @provides?
-- [ ] more accurate key fields comparison (I did string ≠ string but we need to make it better)
-- [ ] support `@interfaceObject`
-- [ ] support `[String!]!` and `[String!]` comparison, not only `String!` vs `String`

package/cjs/subgraph/helpers.js

@@ -111,7 +111,7 @@ function visitFields({ context, selectionSet, typeDefinition, interceptField, in
                 interceptUnknownField,
                 interceptInterfaceType,
             });
-            break;
+            continue;
         }
         const selectionFieldDef = selection.name.value === '__typename'
             ? {

package/cjs/subgraph/state.js

@@ -42,14 +42,23 @@ function createSubgraphStateBuilder(graph, typeDefs, version, links) {
         version,
     };
     const schemaDef = typeDefs.definitions.find(isSchemaDefinition);
+    const leafTypeNames = new Set(specifiedScalars);
+    for (const typeDef of typeDefs.definitions) {
+        if (typeDef.kind === graphql_1.Kind.SCALAR_TYPE_DEFINITION ||
+            typeDef.kind === graphql_1.Kind.SCALAR_TYPE_EXTENSION ||
+            typeDef.kind === graphql_1.Kind.ENUM_TYPE_DEFINITION ||
+            typeDef.kind === graphql_1.Kind.ENUM_TYPE_EXTENSION) {
+            leafTypeNames.add(typeDef.name.value);
+        }
+    }
     const expectedQueryTypeName = decideOnRootTypeName(schemaDef, graphql_1.OperationTypeNode.QUERY, 'Query');
     const expectedMutationTypeName = decideOnRootTypeName(schemaDef, graphql_1.OperationTypeNode.MUTATION, 'Mutation');
     const expectedSubscriptionTypeName = decideOnRootTypeName(schemaDef, graphql_1.OperationTypeNode.SUBSCRIPTION, 'Subscription');
     const composedDirectives = new Set();
     const directiveBuilder = directiveFactory(state);
     const scalarTypeBuilder = scalarTypeFactory(state);
-    const objectTypeBuilder = objectTypeFactory(state, renameObjectType);
     const interfaceTypeBuilder = interfaceTypeFactory(state);
+    const objectTypeBuilder = objectTypeFactory(state, renameObjectType, interfaceTypeBuilder, isInterfaceObject);
     const inputObjectTypeBuilder = inputObjectTypeFactory(state);
     const unionTypeBuilder = unionTypeFactory(state);
     const enumTypeBuilder = enumTypeFactory(state);
@@ -65,7 +74,18 @@ function createSubgraphStateBuilder(graph, typeDefs, version, links) {
         }
         return typeName;
     }
+    function isInterfaceObject(typeName) {
+        const found = state.types.get(typeName);
+        if (!found) {
+            return false;
+        }
+        if (found.kind !== TypeKind.INTERFACE) {
+            return false;
+        }
+        return found.isInterfaceObject;
+    }
     return {
+        isInterfaceObject,
         directive: directiveBuilder,
         scalarType: scalarTypeBuilder,
         objectType: objectTypeBuilder,
@@ -92,18 +112,26 @@ function createSubgraphStateBuilder(graph, typeDefs, version, links) {
                     const isObjectType = typeDef.kind === graphql_1.Kind.OBJECT_TYPE_DEFINITION ||
                         typeDef.kind === graphql_1.Kind.OBJECT_TYPE_EXTENSION;
                     const outputTypeName = resolveTypeName(node.type);
+                    const isLeaf = leafTypeNames.has(outputTypeName);
                     const referencesEnumType = enumTypesByName.has(outputTypeName);
                     if (referencesEnumType) {
                         enumTypeBuilder.setReferencedByOutputType(outputTypeName, `${typeDef.name.value}.${node.name.value}`);
                     }
-                    if (isInterfaceType) {
+                    if (isInterfaceType || isInterfaceObject(typeDef.name.value)) {
                         interfaceTypeBuilder.field.setType(typeDef.name.value, node.name.value, (0, helpers_js_1.printOutputType)(node.type));
+                        interfaceTypeBuilder.field.setUsed(typeDef.name.value, node.name.value);
+                        if (isLeaf) {
+                            interfaceTypeBuilder.field.setLeaf(typeDef.name.value, node.name.value);
+                        }
                         return;
                     }
                     if (!isObjectType) {
                         throw new Error(`Expected to find an object type`);
                     }
                     objectTypeBuilder.field.setType(typeDef.name.value, node.name.value, (0, helpers_js_1.printOutputType)(node.type));
+                    if (isLeaf) {
+                        objectTypeBuilder.field.setLeaf(typeDef.name.value, node.name.value);
+                    }
                     if (typeDef.kind === graphql_1.Kind.OBJECT_TYPE_EXTENSION) {
                         objectTypeBuilder.field.setExtension(typeDef.name.value, node.name.value);
                     }
@@ -155,6 +183,16 @@ function createSubgraphStateBuilder(graph, typeDefs, version, links) {
                     }
                 },
                 ObjectTypeDefinition(node) {
+                    if (hasInterfaceObjectDirective(node)) {
+                        interfaceTypeBuilder.setDefinition(node.name.value);
+                        interfaceTypeBuilder.setInterfaceObject(node.name.value);
+                        if (node.interfaces) {
+                            for (const interfaceNode of node.interfaces) {
+                                interfaceTypeBuilder.setInterface(node.name.value, interfaceNode.name.value);
+                            }
+                        }
+                        return;
+                    }
                     objectTypeBuilder.setDefinition(node.name.value);
                     if (node.name.value === expectedQueryTypeName) {
                         state.schema.queryType = renameObjectType(node.name.value);
@@ -172,6 +210,8 @@ function createSubgraphStateBuilder(graph, typeDefs, version, links) {
                     }
                 },
                 ObjectTypeExtension(node) {
+                    if (hasInterfaceObjectDirective(node)) {
+                    }
                     if (node.name.value === expectedQueryTypeName) {
                         state.schema.queryType = renameObjectType(node.name.value);
                     }
@@ -539,12 +579,18 @@ function scalarTypeFactory(state) {
         },
     };
 }
-function objectTypeFactory(state, renameObject) {
+function objectTypeFactory(state, renameObject, interfaceTypeBuilder, isInterfaceObject) {
     return {
         setDefinition(typeName) {
+            if (isInterfaceObject(typeName)) {
+                return interfaceTypeBuilder.setDefinition(typeName);
+            }
             getOrCreateObjectType(state, renameObject, typeName).isDefinition = true;
         },
         setExtension(typeName, extensionType) {
+            if (isInterfaceObject(typeName)) {
+                return interfaceTypeBuilder.setExtension(typeName);
+            }
             const objectType = getOrCreateObjectType(state, renameObject, typeName);
             objectType.extension = true;
             if (objectType.extensionType !== '@extends') {
@@ -552,9 +598,15 @@ function objectTypeFactory(state, renameObject) {
             }
         },
         setDescription(typeName, description) {
+            if (isInterfaceObject(typeName)) {
+                return interfaceTypeBuilder.setDescription(typeName, description);
+            }
             getOrCreateObjectType(state, renameObject, typeName).description = description;
         },
         setExternal(typeName) {
+            if (isInterfaceObject(typeName)) {
+                return;
+            }
             const objectType = getOrCreateObjectType(state, renameObject, typeName);
             objectType.external = true;
             for (const field of objectType.fields.values()) {
@@ -562,10 +614,16 @@ function objectTypeFactory(state, renameObject) {
             }
         },
         setInterface(typeName, interfaceName) {
+            if (isInterfaceObject(typeName)) {
+                return interfaceTypeBuilder.setInterface(typeName, interfaceName);
+            }
             getOrCreateObjectType(state, renameObject, typeName).interfaces.add(interfaceName);
             getOrCreateInterfaceType(state, interfaceName).implementedBy.add(typeName);
         },
         setKey(typeName, fields, fieldsUsedInKey, resolvable) {
+            if (isInterfaceObject(typeName)) {
+                return interfaceTypeBuilder.setKey(typeName, fields, fieldsUsedInKey, resolvable);
+            }
             const objectType = getOrCreateObjectType(state, renameObject, typeName);
             objectType.keys.push({ fields, resolvable });
             for (const field of fieldsUsedInKey) {
@@ -573,110 +631,212 @@ function objectTypeFactory(state, renameObject) {
             }
         },
         setInaccessible(typeName) {
+            if (isInterfaceObject(typeName)) {
+                return interfaceTypeBuilder.setInaccessible(typeName);
+            }
             const objectType = getOrCreateObjectType(state, renameObject, typeName);
             objectType.inaccessible = true;
         },
         setAuthenticated(typeName) {
+            if (isInterfaceObject(typeName)) {
+                return interfaceTypeBuilder.setAuthenticated(typeName);
+            }
             const objectType = getOrCreateObjectType(state, renameObject, typeName);
             objectType.authenticated = true;
         },
         setPolicies(typeName, policies) {
+            if (isInterfaceObject(typeName)) {
+                return interfaceTypeBuilder.setPolicies(typeName, policies);
+            }
             getOrCreateObjectType(state, renameObject, typeName).policies.push(...policies);
         },
         setScopes(typeName, scopes) {
+            if (isInterfaceObject(typeName)) {
+                return interfaceTypeBuilder.setScopes(typeName, scopes);
+            }
             getOrCreateObjectType(state, renameObject, typeName).scopes.push(...scopes);
         },
         setShareable(typeName) {
+            if (isInterfaceObject(typeName)) {
+                return;
+            }
             getOrCreateObjectType(state, renameObject, typeName).shareable = true;
         },
         setTag(typeName, tag) {
+            if (isInterfaceObject(typeName)) {
+                return interfaceTypeBuilder.setTag(typeName, tag);
+            }
             getOrCreateObjectType(state, renameObject, typeName).tags.add(tag);
         },
         setDirective(typeName, directive) {
+            if (isInterfaceObject(typeName)) {
+                return interfaceTypeBuilder.setDirective(typeName, directive);
+            }
             getOrCreateObjectType(state, renameObject, typeName).ast.directives.push(directive);
         },
         field: {
             setType(typeName, fieldName, fieldType) {
+                if (isInterfaceObject(typeName)) {
+                    return interfaceTypeBuilder.field.setType(typeName, fieldName, fieldType);
+                }
                 getOrCreateObjectField(state, renameObject, typeName, fieldName).type = fieldType;
             },
+            setLeaf(typeName, fieldName) {
+                if (isInterfaceObject(typeName)) {
+                    return interfaceTypeBuilder.field.setLeaf(typeName, fieldName);
+                }
+                getOrCreateObjectField(state, renameObject, typeName, fieldName).isLeaf = true;
+            },
             setExtension(typeName, fieldName) {
+                if (isInterfaceObject(typeName)) {
+                    return;
+                }
                 getOrCreateObjectField(state, renameObject, typeName, fieldName).extension = true;
             },
             setDirective(typeName, fieldName, directive) {
+                if (isInterfaceObject(typeName)) {
+                    return interfaceTypeBuilder.field.setDirective(typeName, fieldName, directive);
+                }
                 getOrCreateObjectField(state, renameObject, typeName, fieldName).ast.directives.push(directive);
             },
             setDescription(typeName, fieldName, description) {
+                if (isInterfaceObject(typeName)) {
+                    return interfaceTypeBuilder.field.setDescription(typeName, fieldName, description);
+                }
                 getOrCreateObjectField(state, renameObject, typeName, fieldName).description = description;
             },
             setDeprecated(typeName, fieldName, reason) {
+                if (isInterfaceObject(typeName)) {
+                    return interfaceTypeBuilder.field.setDeprecated(typeName, fieldName, reason);
+                }
                 getOrCreateObjectField(state, renameObject, typeName, fieldName).deprecated = {
                     reason,
                     deprecated: true,
                 };
             },
             setAuthenticated(typeName, fieldName) {
+                if (isInterfaceObject(typeName)) {
+                    return interfaceTypeBuilder.field.setAuthenticated(typeName, fieldName);
+                }
                 getOrCreateObjectField(state, renameObject, typeName, fieldName).authenticated = true;
             },
             setPolicies(typeName, fieldName, policies) {
+                if (isInterfaceObject(typeName)) {
+                    return interfaceTypeBuilder.field.setPolicies(typeName, fieldName, policies);
+                }
                 getOrCreateObjectField(state, renameObject, typeName, fieldName).policies.push(...policies);
             },
             setScopes(typeName, fieldName, scopes) {
+                if (isInterfaceObject(typeName)) {
+                    return interfaceTypeBuilder.field.setScopes(typeName, fieldName, scopes);
+                }
                 getOrCreateObjectField(state, renameObject, typeName, fieldName).scopes.push(...scopes);
             },
             setExternal(typeName, fieldName) {
+                if (isInterfaceObject(typeName)) {
+                    return interfaceTypeBuilder.field.setExternal(typeName, fieldName);
+                }
                 getOrCreateObjectField(state, renameObject, typeName, fieldName).external = true;
             },
             setInaccessible(typeName, fieldName) {
+                if (isInterfaceObject(typeName)) {
+                    return interfaceTypeBuilder.field.setInaccessible(typeName, fieldName);
+                }
                 getOrCreateObjectField(state, renameObject, typeName, fieldName).inaccessible = true;
             },
             setOverride(typeName, fieldName, override) {
+                if (isInterfaceObject(typeName)) {
+                    return interfaceTypeBuilder.field.setOverride(typeName, fieldName, override);
+                }
                 getOrCreateObjectField(state, renameObject, typeName, fieldName).override = override;
             },
             setProvides(typeName, fieldName, provides) {
+                if (isInterfaceObject(typeName)) {
+                    return;
+                }
                 getOrCreateObjectField(state, renameObject, typeName, fieldName).provides = provides;
             },
             setRequires(typeName, fieldName, requires) {
+                if (isInterfaceObject(typeName)) {
+                    return interfaceTypeBuilder.field.setRequires(typeName, fieldName, requires);
+                }
                 getOrCreateObjectField(state, renameObject, typeName, fieldName).requires = requires;
             },
             markAsProvided(typeName, fieldName) {
+                if (isInterfaceObject(typeName)) {
+                    return;
+                }
                 getOrCreateObjectField(state, renameObject, typeName, fieldName).provided = true;
             },
             markedAsRequired(typeName, fieldName) {
+                if (isInterfaceObject(typeName)) {
+                    return;
+                }
                 getOrCreateObjectField(state, renameObject, typeName, fieldName).required = true;
             },
             setShareable(typeName, fieldName) {
+                if (isInterfaceObject(typeName)) {
+                    return interfaceTypeBuilder.field.setShareable(typeName, fieldName);
+                }
                 getOrCreateObjectField(state, renameObject, typeName, fieldName).shareable = true;
             },
             setTag(typeName, fieldName, tag) {
+                if (isInterfaceObject(typeName)) {
+                    return interfaceTypeBuilder.field.setTag(typeName, fieldName, tag);
+                }
                 getOrCreateObjectField(state, renameObject, typeName, fieldName).tags.add(tag);
             },
             setUsed(typeName, fieldName) {
+                if (isInterfaceObject(typeName)) {
+                    return interfaceTypeBuilder.field.setUsed(typeName, fieldName);
+                }
                 getOrCreateObjectField(state, renameObject, typeName, fieldName).used = true;
             },
             arg: {
                 setType(typeName, fieldName, argName, argType) {
+                    if (isInterfaceObject(typeName)) {
+                        return interfaceTypeBuilder.field.arg.setType(typeName, fieldName, argName, argType);
+                    }
                     getOrCreateObjectFieldArgument(state, renameObject, typeName, fieldName, argName).type =
                         argType;
                 },
                 setDescription(typeName, fieldName, argName, description) {
+                    if (isInterfaceObject(typeName)) {
+                        return interfaceTypeBuilder.field.arg.setDescription(typeName, fieldName, argName, description);
+                    }
                     getOrCreateObjectFieldArgument(state, renameObject, typeName, fieldName, argName).description = description;
                 },
                 setDeprecated(typeName, fieldName, argName, reason) {
+                    if (isInterfaceObject(typeName)) {
+                        return interfaceTypeBuilder.field.arg.setDeprecated(typeName, fieldName, argName, reason);
+                    }
                     getOrCreateObjectFieldArgument(state, renameObject, typeName, fieldName, argName).deprecated = {
                         reason,
                         deprecated: true,
                     };
                 },
                 setDirective(typeName, fieldName, argName, directive) {
+                    if (isInterfaceObject(typeName)) {
+                        return interfaceTypeBuilder.field.arg.setDirective(typeName, fieldName, argName, directive);
+                    }
                     getOrCreateObjectFieldArgument(state, renameObject, typeName, fieldName, argName).ast.directives.push(directive);
                 },
                 setDefaultValue(typeName, fieldName, argName, defaultValue) {
+                    if (isInterfaceObject(typeName)) {
+                        return interfaceTypeBuilder.field.arg.setDefaultValue(typeName, fieldName, argName, defaultValue);
+                    }
                     getOrCreateObjectFieldArgument(state, renameObject, typeName, fieldName, argName).defaultValue = defaultValue;
                 },
                 setInaccessible(typeName, fieldName, argName) {
+                    if (isInterfaceObject(typeName)) {
+                        return interfaceTypeBuilder.field.arg.setInaccessible(typeName, fieldName, argName);
+                    }
                     getOrCreateObjectFieldArgument(state, renameObject, typeName, fieldName, argName).inaccessible = true;
                 },
                 setTag(typeName, fieldName, argName, tag) {
+                    if (isInterfaceObject(typeName)) {
+                        return interfaceTypeBuilder.field.arg.setTag(typeName, fieldName, argName, tag);
+                    }
                     getOrCreateObjectFieldArgument(state, renameObject, typeName, fieldName, argName).tags.add(tag);
                 },
             },
@@ -694,8 +854,15 @@ function interfaceTypeFactory(state) {
         setInterface(typeName, interfaceName) {
             getOrCreateInterfaceType(state, typeName).interfaces.add(interfaceName);
         },
+        setInterfaceObject(typeName) {
+            getOrCreateInterfaceType(state, typeName).isInterfaceObject = true;
+        },
         setKey(typeName, fields, fieldsUsedInKey, resolvable) {
-            getOrCreateInterfaceType(state, typeName).keys.push({ fields, resolvable });
+            const interfaceType = getOrCreateInterfaceType(state, typeName);
+            interfaceType.keys.push({ fields, resolvable });
+            for (const field of fieldsUsedInKey) {
+                interfaceType.fieldsUsedAsKeys.add(field);
+            }
         },
         setInaccessible(typeName) {
             const objectType = getOrCreateInterfaceType(state, typeName);
@@ -724,6 +891,9 @@ function interfaceTypeFactory(state) {
             setType(typeName, fieldName, fieldType) {
                 getOrCreateInterfaceField(state, typeName, fieldName).type = fieldType;
             },
+            setLeaf(typeName, fieldName) {
+                getOrCreateInterfaceField(state, typeName, fieldName).isLeaf = true;
+            },
             setExternal(typeName, fieldName) {
                 getOrCreateInterfaceField(state, typeName, fieldName).external = true;
             },
@@ -1020,6 +1190,7 @@ function getOrCreateInterfaceType(state, typeName) {
         kind: TypeKind.INTERFACE,
         name: typeName,
         fields: new Map(),
+        fieldsUsedAsKeys: new Set(),
         extension: false,
         keys: [],
         inaccessible: false,
@@ -1030,6 +1201,7 @@ function getOrCreateInterfaceType(state, typeName) {
         interfaces: new Set(),
         implementedBy: new Set(),
         isDefinition: false,
+        isInterfaceObject: false,
         ast: {
             directives: [],
         },
@@ -1111,6 +1283,8 @@ function getOrCreateObjectField(state, renameObject, typeName, fieldName) {
     const field = {
         name: fieldName,
         type: MISSING,
+        usedAsKey: false,
+        isLeaf: false,
         external: false,
         inaccessible: false,
         authenticated: false,
@@ -1141,6 +1315,8 @@ function getOrCreateInterfaceField(state, typeName, fieldName) {
     }
     const field = {
         name: fieldName,
+        usedAsKey: false,
+        isLeaf: false,
         type: MISSING,
         external: false,
         inaccessible: false,
@@ -1251,3 +1427,6 @@ function decideOnRootTypeName(schemaDef, kind, defaultName) {
     return (schemaDef?.operationTypes?.find(operationType => operationType.operation === kind)?.type.name
         .value ?? defaultName);
 }
+function hasInterfaceObjectDirective(node) {
+    return node.directives?.some(d => d.name.value === 'interfaceObject');
+}

package/cjs/subgraph/validation/rules/elements/interface-object.js

@@ -12,9 +12,25 @@ function InterfaceObjectRules(context) {
             if (!context.isAvailableFederationDirective('interfaceObject', node)) {
                 return;
             }
-            context.reportError(new graphql_1.GraphQLError(`@interfaceObject is not yet supported. See https://github.com/the-guild-org/federation/issues/7`, {
-                extensions: { code: 'UNSUPPORTED_FEATURE' },
-            }));
+            if (context.satisfiesVersionRange('< v2.3')) {
+                context.reportError(new graphql_1.GraphQLError(`@interfaceObject is not yet supported. See https://github.com/the-guild-org/federation/issues/7`, {
+                    extensions: { code: 'UNSUPPORTED_FEATURE' },
+                }));
+                return;
+            }
+            const typeDef = context.typeNodeInfo.getTypeDef();
+            if (!typeDef) {
+                return;
+            }
+            if (typeDef.kind !== graphql_1.Kind.OBJECT_TYPE_DEFINITION &&
+                typeDef.kind !== graphql_1.Kind.OBJECT_TYPE_EXTENSION) {
+                return;
+            }
+            if (!typeDef.directives?.some(d => d.name.value === 'key')) {
+                context.reportError(new graphql_1.GraphQLError(`The @interfaceObject directive can only be applied to entity types but type "${typeDef.name.value}" has no @key in this subgraph.`, {
+                    extensions: { code: 'INTERFACE_OBJECT_USAGE_ERROR' },
+                }));
+            }
         },
     };
 }

package/cjs/subgraph/validation/rules/elements/key.js

@@ -18,9 +18,10 @@ function KeyRules(context) {
                 return;
             }
             const typeCoordinate = typeDef.name.value;
-            const usedOnInterface = typeDef.kind === graphql_1.Kind.INTERFACE_TYPE_DEFINITION ||
-                typeDef.kind === graphql_1.Kind.INTERFACE_TYPE_EXTENSION;
             const usedOnObject = typeDef.kind === graphql_1.Kind.OBJECT_TYPE_DEFINITION || typeDef.kind === graphql_1.Kind.OBJECT_TYPE_EXTENSION;
+            const usedOnInterface = typeDef.kind === graphql_1.Kind.INTERFACE_TYPE_DEFINITION ||
+                typeDef.kind === graphql_1.Kind.INTERFACE_TYPE_EXTENSION ||
+                (usedOnObject && context.stateBuilder.isInterfaceObject(typeDef.name.value));
             if (!usedOnObject && !usedOnInterface) {
                 return;
             }

package/cjs/subgraph/validation/rules/elements/policy.js

@@ -55,8 +55,9 @@ function PolicyRule(context) {
                     if (!typeDef) {
                         throw new Error('Could not find the parent type of the field annotated with @policy');
                     }
-                    if (typeDef.kind === graphql_1.Kind.OBJECT_TYPE_DEFINITION ||
-                        typeDef.kind === graphql_1.Kind.OBJECT_TYPE_EXTENSION) {
+                    if ((typeDef.kind === graphql_1.Kind.OBJECT_TYPE_DEFINITION ||
+                        typeDef.kind === graphql_1.Kind.OBJECT_TYPE_EXTENSION) &&
+                        !context.stateBuilder.isInterfaceObject(typeDef.name.value)) {
                         context.stateBuilder.objectType.field.setPolicies(typeDef.name.value, parent.name.value, policies);
                     }
                     break;

package/cjs/subgraph/validation/rules/elements/shareable.js

@@ -17,8 +17,9 @@ function ShareableRules(context) {
             if (!typeDef) {
                 return;
             }
-            if (typeDef.kind === graphql_1.Kind.OBJECT_TYPE_DEFINITION ||
-                typeDef.kind === graphql_1.Kind.OBJECT_TYPE_EXTENSION) {
+            if ((typeDef.kind === graphql_1.Kind.OBJECT_TYPE_DEFINITION ||
+                typeDef.kind === graphql_1.Kind.OBJECT_TYPE_EXTENSION) &&
+                !context.stateBuilder.isInterfaceObject(typeDef.name.value)) {
                 if (fieldDef) {
                     context.stateBuilder.objectType.field.setShareable(typeDef.name.value, fieldDef.name.value);
                 }

package/cjs/subgraph/validation/rules/elements/tag.js

@@ -45,7 +45,8 @@ function TagRules(context) {
                         throw new Error('Could not find the parent type of the field annotated with @tag');
                     }
                     if (typeDef.kind === graphql_1.Kind.INTERFACE_TYPE_DEFINITION ||
-                        typeDef.kind === graphql_1.Kind.INTERFACE_TYPE_EXTENSION) {
+                        typeDef.kind === graphql_1.Kind.INTERFACE_TYPE_EXTENSION ||
+                        context.stateBuilder.isInterfaceObject(typeDef.name.value)) {
                         context.stateBuilder.interfaceType.field.setTag(typeDef.name.value, parent.name.value, tag);
                     }
                     else {

package/cjs/subgraph/validation/rules/known-federation-directive-rule.js

@@ -22,6 +22,10 @@ function KnownFederationDirectivesRule(context) {
     return {
         Directive(node) {
             const name = node.name.value;
+            if (!availableDirectivesSet.has(name) && name === 'interfaceObject') {
+                context.reportError(new graphql_1.GraphQLError(`Unknown directive "@interfaceObject". If you meant the "@interfaceObject" federation 2 directive, note that this schema is a federation 1 schema. To be a federation 2 schema, it needs to @link to the federation specification v2.`, { nodes: node, extensions: { code: 'INVALID_GRAPHQL' } }));
+                return;
+            }
             if (!availableDirectivesSet.has(name) &&
                 knownDirectivesSet.has(name) &&
                 !name.startsWith('federation__')) {

package/cjs/subgraph/validation/rules/only-interface-implementation-rule.js

@@ -0,0 +1,67 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OnlyInterfaceImplementationRule = void 0;
+const graphql_1 = require("graphql");
+function OnlyInterfaceImplementationRule(context) {
+    const { definitions } = context.getDocument();
+    let filled = false;
+    const typeNameToKind = new Map();
+    function fillTypeNameToKindMap() {
+        for (const node of definitions) {
+            switch (node.kind) {
+                case graphql_1.Kind.OBJECT_TYPE_DEFINITION:
+                case graphql_1.Kind.OBJECT_TYPE_EXTENSION:
+                    typeNameToKind.set(node.name.value, 'ObjectType');
+                    break;
+                case graphql_1.Kind.INTERFACE_TYPE_DEFINITION:
+                case graphql_1.Kind.INTERFACE_TYPE_EXTENSION:
+                    typeNameToKind.set(node.name.value, 'InterfaceType');
+                    break;
+                case graphql_1.Kind.UNION_TYPE_DEFINITION:
+                case graphql_1.Kind.UNION_TYPE_EXTENSION:
+                    typeNameToKind.set(node.name.value, 'UnionType');
+                    break;
+                case graphql_1.Kind.ENUM_TYPE_DEFINITION:
+                case graphql_1.Kind.ENUM_TYPE_EXTENSION:
+                    typeNameToKind.set(node.name.value, 'EnumType');
+                    break;
+                case graphql_1.Kind.SCALAR_TYPE_DEFINITION:
+                case graphql_1.Kind.SCALAR_TYPE_EXTENSION:
+                    typeNameToKind.set(node.name.value, 'ScalarType');
+                    break;
+                case graphql_1.Kind.INPUT_OBJECT_TYPE_DEFINITION:
+                case graphql_1.Kind.INPUT_OBJECT_TYPE_EXTENSION:
+                    typeNameToKind.set(node.name.value, 'InputObjectType');
+                    break;
+            }
+        }
+        filled = true;
+    }
+    function findKindByName(typeName) {
+        if (!filled) {
+            fillTypeNameToKindMap();
+        }
+        return typeNameToKind.get(typeName);
+    }
+    function check(node) {
+        if (!node.interfaces) {
+            return;
+        }
+        for (const interfaceNode of node.interfaces) {
+            const interfaceName = interfaceNode.name.value;
+            const kind = findKindByName(interfaceName);
+            if (kind && kind !== 'InterfaceType') {
+                context.reportError(new graphql_1.GraphQLError(`Cannot implement non-interface type ${interfaceName} (of type ObjectType)`, {
+                    extensions: {
+                        code: 'INVALID_GRAPHQL',
+                    },
+                }));
+            }
+        }
+    }
+    return {
+        ObjectTypeDefinition: check,
+        ObjectTypeExtension: check,
+    };
+}
+exports.OnlyInterfaceImplementationRule = OnlyInterfaceImplementationRule;

package/cjs/subgraph/validation/validate-subgraph.js

@@ -26,6 +26,7 @@ const known_federation_directive_rule_js_1 = require("./rules/known-federation-d
 const known_root_type_rule_js_1 = require("./rules/known-root-type-rule.js");
 const known_type_names_rule_js_1 = require("./rules/known-type-names-rule.js");
 const lone_schema_definition_rule_js_1 = require("./rules/lone-schema-definition-rule.js");
+const only_interface_implementation_rule_js_1 = require("./rules/only-interface-implementation-rule.js");
 const provided_arguments_on_directives_rule_js_1 = require("./rules/provided-arguments-on-directives-rule.js");
 const provided_required_arguments_on_directives_rule_js_1 = require("./rules/provided-required-arguments-on-directives-rule.js");
 const query_root_type_inaccessible_rule_js_1 = require("./rules/query-root-type-inaccessible-rule.js");
@@ -116,6 +117,7 @@ function validateSubgraph(subgraph, stateBuilder, federation, __internal) {
         compose_directive_js_1.ComposeDirectiveRules,
     ];
     const graphqlRules = [
+        only_interface_implementation_rule_js_1.OnlyInterfaceImplementationRule,
         lone_schema_definition_rule_js_1.LoneSchemaDefinitionRule,
         unique_operation_types_rule_js_1.UniqueOperationTypesRule,
         unique_type_names_rule_js_1.UniqueTypeNamesRule,