Add integration test suite for GraphQL emitter

Expands the test coverage of the component-based emitter to exercise
the full surface area of TypeSpec-to-GraphQL translation.

New test files:
- nullability.test.ts: required vs. optional vs. T | null, input and output
  side semantics, list element nullability
- input-output-splitting.test.ts: models used as input, output, or both;
  verifies correct suffixing and separation
- unions.test.ts: named union types, nullable variants, wrapper models
- enums.test.ts: enum declarations, enum values, enum references in
  model properties and operations
- arrays.test.ts: array element non-null semantics and nested arrays
- circular-references.test.ts: self-referential and mutually recursive
  model definitions
- deprecation.test.ts: @deprecated decorator propagation to SDL
- doc-comments.test.ts: doc-comment propagation to SDL descriptions

Extends e2e.test.ts beyond the single smoke test into a full scenario
suite (complete API schema, custom scalars, union output types, models
used only as input, mutations, empty schema handling, operation
parameters, and complex SDL validation).

Extends test/main.tsp with the fixture models, operations, and helpers
needed by the e2e and integration tests.

No production code changes — this PR is tests only.

Author: FionaBronwen

packages/graphql/test/arrays.test.ts

@@ -0,0 +1,72 @@
+import { strictEqual } from "node:assert";
+import { describe, it } from "vitest";
+import { emitSingleSchema } from "./test-host.js";
+
+describe("arrays", () => {
+  it("supports array types", async () => {
+    const code = `
+      @schema
+      namespace TestNamespace {
+        model Tag {
+          name: string;
+          color: string;
+        }
+
+        model Article {
+          id: string;
+          title: string;
+          tags: Tag[];
+          categories: string[];
+        }
+
+        @query
+        op getArticle(id: string): Article;
+
+        @query
+        op listArticles(): Article[];
+      }
+    `;
+
+    const result = await emitSingleSchema(code, {});
+
+    strictEqual(result.includes("tags: [Tag!]!"), true);
+    strictEqual(result.includes("categories: [String!]!"), true);
+    strictEqual(result.includes("listArticles: [Article!]"), true);
+  });
+
+  it("emits list types for array properties", async () => {
+    const code = `
+      @schema
+      namespace TestNamespace {
+        model User {
+          id: string;
+          tags: string[];
+        }
+
+        @query
+        op getUser(): User;
+      }
+    `;
+
+    const result = await emitSingleSchema(code, {});
+    strictEqual(result.includes("tags: [String!]!"), true);
+  });
+
+  it("emits nullable list items for optional element types", async () => {
+    const code = `
+      @schema
+      namespace TestNamespace {
+        model User {
+          id: string;
+          tags: (string | null)[];
+        }
+
+        @query
+        op getUser(): User;
+      }
+    `;
+
+    const result = await emitSingleSchema(code, {});
+    strictEqual(result.includes("tags: [String]!"), true);
+  });
+});

packages/graphql/test/circular-references.test.ts

@@ -0,0 +1,47 @@
+import { strictEqual } from "node:assert";
+import { describe, it } from "vitest";
+import { emitSingleSchema } from "./test-host.js";
+
+describe("circular references", () => {
+  it("handles circular references between models", async () => {
+    const code = `
+      @schema
+      namespace TestNamespace {
+        model User {
+          id: string;
+          name: string;
+          posts: Post[];
+        }
+
+        model Post {
+          id: string;
+          title: string;
+          author: User;
+          comments: Comment[];
+        }
+
+        model Comment {
+          id: string;
+          text: string;
+          author: User;
+          post: Post;
+        }
+
+        @query
+        op getUser(id: string): User;
+
+        @query
+        op getPost(id: string): Post;
+      }
+    `;
+
+    const result = await emitSingleSchema(code, {});
+
+    strictEqual(result.includes("type User {"), true);
+    strictEqual(result.includes("posts: [Post!]!"), true);
+    strictEqual(result.includes("type Post {"), true);
+    strictEqual(result.includes("author: User!"), true);
+    strictEqual(result.includes("comments: [Comment!]!"), true);
+    strictEqual(result.includes("type Comment {"), true);
+  });
+});

packages/graphql/test/deprecation.test.ts

@@ -0,0 +1,31 @@
+import { strictEqual } from "node:assert";
+import { describe, it } from "vitest";
+import { emitSingleSchema } from "./test-host.js";
+
+describe("deprecation", () => {
+  it("supports @deprecated directive", async () => {
+    const code = `
+      @schema
+      namespace TestNamespace {
+        model User {
+          id: string;
+          name: string;
+          #deprecated "Use email instead"
+          username: string;
+        }
+
+        @query
+        op getUser(id: string): User;
+
+        #deprecated "Use getUserById instead"
+        @query
+        op findUser(id: string): User;
+      }
+    `;
+
+    const result = await emitSingleSchema(code, {});
+
+    strictEqual(result.includes('@deprecated(reason: "Use email instead")'), true);
+    strictEqual(result.includes('@deprecated(reason: "Use getUserById instead")'), true);
+  });
+});

packages/graphql/test/doc-comments.test.ts

@@ -0,0 +1,70 @@
+import { strictEqual } from "node:assert";
+import { describe, it } from "vitest";
+import { emitSingleSchema } from "./test-host.js";
+
+describe("doc comments", () => {
+  it("propagates doc comments to model descriptions", async () => {
+    const code = `
+      @schema
+      namespace TestNamespace {
+        /** A user in the system */
+        model User {
+          id: string;
+          name: string;
+        }
+
+        @query
+        op getUser(id: string): User;
+      }
+    `;
+
+    const result = await emitSingleSchema(code, {});
+    strictEqual(result.includes('"""A user in the system"""'), true);
+  });
+
+  it("propagates doc comments to field descriptions", async () => {
+    const code = `
+      @schema
+      namespace TestNamespace {
+        model User {
+          /** The unique identifier */
+          id: string;
+          /** The user's display name */
+          name: string;
+        }
+
+        @query
+        op getUser(id: string): User;
+      }
+    `;
+
+    const result = await emitSingleSchema(code, {});
+    strictEqual(result.includes('"""The unique identifier"""'), true);
+    strictEqual(result.includes('"""The user\'s display name"""'), true);
+  });
+
+  it("propagates doc comments to enum descriptions", async () => {
+    const code = `
+      @schema
+      namespace TestNamespace {
+        /** The role of a user */
+        enum Role {
+          /** Administrator with full access */
+          Admin,
+          /** Regular user */
+          User,
+        }
+
+        model Person {
+          role: Role;
+        }
+
+        @query
+        op getPerson(): Person;
+      }
+    `;
+
+    const result = await emitSingleSchema(code, {});
+    strictEqual(result.includes('"""The role of a user"""'), true);
+  });
+});