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/fields/type-expression.tsx

@@ -7,7 +7,6 @@ import {
 } from "@typespec/compiler";
 import { type Children } from "@alloy-js/core";
 import { useTsp } from "@typespec/emitter-framework";
-import { useGraphQLSchema } from "../../context/index.js";
 import { isNullable } from "../../lib/nullable.js";
 import { unwrapNullableUnion, getUnionName } from "../../lib/type-utils.js";
 import { getGraphQLBuiltinName, getScalarMapping } from "../../lib/scalar-mappings.js";
@@ -42,7 +41,6 @@ export interface GraphQLTypeExpressionProps {
 
 export function GraphQLTypeExpression(props: GraphQLTypeExpressionProps) {
   const { $, program } = useTsp();
-  const { modelVariants } = useGraphQLSchema();
 
   const nullable = props.isNullable || isNullable(props.type);
 
@@ -145,14 +143,8 @@ export function GraphQLTypeExpression(props: GraphQLTypeExpressionProps) {
     }
 
     if ($.model.is(type)) {
-      // Both input and output variants share the same source model identity,
-      // so we use name-based lookup to determine if both variants exist.
-      const hasOutputVariant = modelVariants.outputModels.has(type.name);
-      const hasInputVariant = modelVariants.inputModels.has(type.name);
-
-      if (props.isInput && hasOutputVariant && hasInputVariant) {
-        return `${type.name}Input`;
-      }
+      // The mutation engine handles input/output naming - input models are
+      // already suffixed with "Input" when they need to be distinguished.
       return type.name;
     }
 

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; }`,
     );