Remove modelVariants workaround from components

The mutation engine now handles all input/output type naming, so components
can use type.name directly without looking up whether a model has both
input and output variants.

Author: FionaBronwen

packages/graphql/src/components/types/input-type.tsx

@@ -1,7 +1,6 @@
 import type { Model } from "@typespec/compiler";
 import * as gql from "@alloy-js/graphql";
 import { useTsp } from "@typespec/emitter-framework";
-import { useGraphQLSchema } from "../../context/index.js";
 import { Field } from "../fields/index.js";
 
 export interface InputTypeProps {
@@ -12,22 +11,16 @@ export interface InputTypeProps {
 /**
  * Renders a GraphQL input type declaration
  *
- * Determines the correct input type name:
- * - If the model is also an output type, appends "Input"
- * - Otherwise, uses the name as-is
+ * The mutation engine handles naming: input models are already suffixed
+ * with "Input" when they need to be distinguished from output types.
  */
 export function InputType(props: InputTypeProps) {
   const { $ } = useTsp();
-  const { modelVariants } = useGraphQLSchema();
   const doc = $.type.getDoc(props.type);
   const properties = Array.from(props.type.properties.values());
 
-  // If there's an output variant with the same name, add Input suffix
-  const hasOutputVariant = modelVariants.outputModels.has(props.type.name);
-  const inputTypeName = hasOutputVariant ? `${props.type.name}Input` : props.type.name;
-
   return (
-    <gql.InputObjectType name={inputTypeName} description={doc}>
+    <gql.InputObjectType name={props.type.name} description={doc}>
       {properties.map((prop) => (
         <Field property={prop} isInput={true} />
       ))}

packages/graphql/test/components/input-type.test.tsx

@@ -49,22 +49,21 @@ describe("InputType component", () => {
     expect(sdl).toContain("bio: String!");
   });
 
-  it("appends Input suffix when model has an output variant", async () => {
-    const { Pet } = await tester.compile(
-      t.code`model ${t.model("Pet")} { name: string; }`,
+  it("renders mutated input model with Input suffix from mutation engine", async () => {
+    // The mutation engine adds the Input suffix when a model is used as input.
+    // This test simulates that by using a model already named with Input suffix.
+    const { PetInput } = await tester.compile(
+      t.code`model ${t.model("PetInput")} { name: string; }`,
     );
 
-    const sdl = renderComponentToSDL(tester.program, <InputType type={Pet} />, {
-      modelVariants: {
-        outputModels: new Map([["Pet", Pet]]),
-        inputModels: new Map([["Pet", Pet]]),
-      },
-    });
+    const sdl = renderComponentToSDL(tester.program, <InputType type={PetInput} />);
 
     expect(sdl).toContain("input PetInput {");
   });
 
-  it("uses original name when no output variant exists", async () => {
+  it("renders input-only model without suffix", async () => {
+    // Models used only as inputs (never as outputs) don't need the Input suffix.
+    // The mutation engine handles this - it only adds suffix when needed.
     const { CreatePet } = await tester.compile(
       t.code`model ${t.model("CreatePet")} { name: string; }`,
     );