Remove XML and urlencoded support, replace mixedContentTypes with listUsers

- Removed application/xml and application/x-www-form-urlencoded content types from updatePetWithForm endpoint
- Replaced mixedContentTypes untagged route with listUsers route
- Removed XML and urlencoded tests from app.test.ts
- Removed json2xml import and xmlparser middleware (no longer needed)
- Added User schema to openapi.yaml components
- Updated api.ts to implement listUsers instead of mixedContentTypes
- Updated tests for new listUsers endpoint

Co-authored-by: jasonblanchard <1238532+jasonblanchard@users.noreply.github.com>

Author: Copilot

examples/tags/api.ts

@@ -108,36 +108,15 @@ export const storeService: ServerTypes.ServerForStore<Request, Response> = {
 // Service implementation for untagged operations
 export const untaggedService: ServerTypes.ServerForUntagged<Request, Response> =
   {
-    mixedContentTypes: async ({
-      parameters,
-      requestBody,
-      contentType,
-    }): ServerTypes.MixedContentTypesResult => {
-      const { petId } = parameters.path;
-      let status: "available" | "pending" | "sold" | undefined;
-
-      // Since each content type has different structures,
-      // use the request content type and requestBody discriminator to narrow the type in each case.
-
-      if (
-        contentType === "application/json" &&
-        requestBody.mediaType === "application/json"
-      ) {
-        status = requestBody.content.jsonstatus;
-      }
-
-      if (
-        contentType == "application/xml" &&
-        requestBody.mediaType === "application/xml"
-      ) {
-        status = requestBody.content.xmlstatus;
-      }
-
+    listUsers: async (): ServerTypes.ListUsersResult => {
       return {
         content: {
           200: {
             "application/json": {
-              pet: { id: petId, name: "dog", status },
+              users: [
+                { id: 1, username: "john_doe", email: "john@example.com" },
+                { id: 2, username: "jane_smith", email: "jane@example.com" },
+              ],
             },
           },
         },

examples/tags/app.test.ts

@@ -2,7 +2,6 @@ import { describe, it } from "node:test";
 import assert from "node:assert";
 import makeApp from "./app.ts";
 import request from "supertest";
-import { json2xml } from "xml-js";
 
 const app = makeApp();
 
@@ -49,81 +48,20 @@ describe("updatePetWithForm", async () => {
       },
     });
   });
-
-  it("accepts xml input", async () => {
-    const xmlData = json2xml(JSON.stringify({ status: "sold" }), {
-      compact: true,
-      ignoreComment: true,
-      spaces: 4,
-    });
-
-    const response = await request(app)
-      .post("/api/v3/pet/123?name=cat")
-      .set("Content-Type", "application/xml")
-      .send(xmlData);
-
-    assert.equal(response.status, 200);
-    assert.deepEqual(response.body, {
-      pet: {
-        id: 123,
-        name: "cat",
-        status: "sold",
-      },
-    });
-  });
-
-  it("accepts form-urlencoded input", async () => {
-    const response = await request(app)
-      .post("/api/v3/pet/123?name=cat")
-      .set("Content-Type", "application/x-www-form-urlencoded")
-      .send("status=sold");
-
-    assert.equal(response.status, 200);
-    assert.deepEqual(response.body, {
-      pet: {
-        id: 123,
-        name: "cat",
-        status: "sold",
-      },
-    });
-  });
 });
 
-describe("mixed content types with different structures", async () => {
-  it("handles json by default", async () => {
-    const response = await request(app)
-      .post("/api/v3/pet/123/mixed-content-types")
-      .send({ jsonstatus: "sold" });
-
-    assert.equal(response.status, 200);
-    assert.deepEqual(response.body, {
-      pet: {
-        id: 123,
-        name: "dog",
-        status: "sold",
-      },
-    });
-  });
-
-  it("handles xml", async () => {
-    const xmlData = json2xml(JSON.stringify({ xmlstatus: "sold" }), {
-      compact: true,
-      ignoreComment: true,
-      spaces: 4,
-    });
-
+describe("listUsers", async () => {
+  it("returns 200", async () => {
     const response = await request(app)
-      .post("/api/v3/pet/123/mixed-content-types")
-      .set("Content-Type", "application/xml")
-      .send(xmlData);
+      .get("/api/v3/users")
+      .set("Accept", "application/json");
 
     assert.equal(response.status, 200);
     assert.deepEqual(response.body, {
-      pet: {
-        id: 123,
-        name: "dog",
-        status: "sold",
-      },
+      users: [
+        { id: 1, username: "john_doe", email: "john@example.com" },
+        { id: 2, username: "jane_smith", email: "jane@example.com" },
+      ],
     });
   });
 });

examples/tags/app.ts

@@ -5,7 +5,6 @@ import registerRoutes from "openapi-typescript-server-express";
 import { petsService, storeService, untaggedService } from "./api.ts";
 import OpenApiValidator from "express-openapi-validator";
 import { NotImplementedError } from "openapi-typescript-server-runtime";
-import xmlparser from "express-xml-bodyparser";
 
 export default function makeApp() {
   const app = express();
@@ -15,7 +14,6 @@ export default function makeApp() {
   });
 
   app.use(express.json());
-  app.use(xmlparser());
   app.use(express.urlencoded({ extended: true }));
 
   const apiRouter = express();

examples/tags/gen/schema.d.ts

@@ -37,16 +37,17 @@ export interface paths {
         patch?: never;
         trace?: never;
     };
-    "/pet/{petId}/mixed-content-types": {
+    "/users": {
         parameters: {
             query?: never;
             header?: never;
             path?: never;
             cookie?: never;
         };
-        get?: never;
+        /** Returns all users from the system */
+        get: operations["listUsers"];
         put?: never;
-        post: operations["mixedContentTypes"];
+        post?: never;
         delete?: never;
         options?: never;
         head?: never;
@@ -132,6 +133,12 @@ export interface components {
              */
             status?: "placed" | "approved" | "delivered";
         };
+        User: {
+            /** Format: int64 */
+            id: number;
+            username: string;
+            email?: string;
+        };
     };
     responses: never;
     parameters: never;
@@ -222,8 +229,6 @@ export interface operations {
         requestBody: {
             content: {
                 "application/json": components["schemas"]["UpdatePetInput"];
-                "application/xml": components["schemas"]["UpdatePetInput"];
-                "application/x-www-form-urlencoded": components["schemas"]["UpdatePetInput"];
             };
         };
         responses: {
@@ -249,37 +254,23 @@ export interface operations {
             };
         };
     };
-    mixedContentTypes: {
+    listUsers: {
         parameters: {
             query?: never;
             header?: never;
-            path: {
-                /** @description ID of pet that needs to be updated */
-                petId: number;
-            };
+            path?: never;
             cookie?: never;
         };
-        requestBody: {
-            content: {
-                "application/json": {
-                    /** @enum {string} */
-                    jsonstatus: "available" | "pending" | "sold";
-                };
-                "application/xml": {
-                    /** @enum {string} */
-                    xmlstatus: "available" | "pending" | "sold";
-                };
-            };
-        };
+        requestBody?: never;
         responses: {
-            /** @description successful operation */
+            /** @description A list of users. */
             200: {
                 headers: {
                     [name: string]: unknown;
                 };
                 content: {
                     "application/json": {
-                        pet?: components["schemas"]["Pet"];
+                        users?: components["schemas"]["User"][];
                     };
                 };
             };

examples/tags/gen/server.ts

@@ -64,14 +64,6 @@ export interface UpdatePetWithFormArgs<Req, Res> {
     mediaType: "application/json";
     content: paths['/pet/{petId}']['post']['requestBody']['content']['application/json']
   }
-  | {
-    mediaType: "application/xml";
-    content: paths['/pet/{petId}']['post']['requestBody']['content']['application/xml']
-  }
-  | {
-    mediaType: "application/x-www-form-urlencoded";
-    content: paths['/pet/{petId}']['post']['requestBody']['content']['application/x-www-form-urlencoded']
-  }
   ;
 }
 
@@ -92,36 +84,27 @@ export async function updatePetWithFormUnimplemented(): UpdatePetWithFormResult
   throw new NotImplementedError()
 }
 
-export interface MixedContentTypesArgs<Req, Res> {
-  parameters: paths['/pet/{petId}/mixed-content-types']['post']['parameters'];
+export interface ListUsersArgs<Req, Res> {
+  parameters: paths['/users']['get']['parameters'];
   contentType: string;
   req: Req;
   res: Res;
-  requestBody: {
-    mediaType: "application/json";
-    content: paths['/pet/{petId}/mixed-content-types']['post']['requestBody']['content']['application/json']
-  }
-  | {
-    mediaType: "application/xml";
-    content: paths['/pet/{petId}/mixed-content-types']['post']['requestBody']['content']['application/xml']
-  }
-  ;
 }
 
-interface MixedContentTypesResult200 {
-  content: { 200: paths['/pet/{petId}/mixed-content-types']['post']['responses']['200']['content'] };
+interface ListUsersResult200 {
+  content: { 200: paths['/users']['get']['responses']['200']['content'] };
   headers?: { [name: string]: any };
 }
 
-interface MixedContentTypesResultDefault {
-  content: { default: paths['/pet/{petId}/mixed-content-types']['post']['responses']['default']['content'] };
+interface ListUsersResultDefault {
+  content: { default: paths['/users']['get']['responses']['default']['content'] };
   headers?: { [name: string]: any };
   status: number;
 }
 
-export type MixedContentTypesResult = Promise<MixedContentTypesResult200 | MixedContentTypesResultDefault>;
+export type ListUsersResult = Promise<ListUsersResult200 | ListUsersResultDefault>;
 
-export async function mixedContentTypesUnimplemented(): MixedContentTypesResult {
+export async function listUsersUnimplemented(): ListUsersResult {
   throw new NotImplementedError()
 }
 
@@ -189,9 +172,10 @@ export interface Server<Req = unknown, Res = unknown> {
   updatePetWithForm: (
     args: UpdatePetWithFormArgs<Req, Res>
   ) => UpdatePetWithFormResult;
-  mixedContentTypes: (
-    args: MixedContentTypesArgs<Req, Res>
-  ) => MixedContentTypesResult;
+  /** Returns all users from the system */
+  listUsers: (
+    args: ListUsersArgs<Req, Res>
+  ) => ListUsersResult;
   getInventory: (
     args: GetInventoryArgs<Req, Res>
   ) => GetInventoryResult;
@@ -218,9 +202,9 @@ export function registerRouteHandlers<Req, Res>(server: Server<Req, Res>): Route
       handler: server.updatePetWithForm as Route["handler"],
     },
     {
-      method: "post",
-      path: "/pet/{petId}/mixed-content-types",
-      handler: server.mixedContentTypes as Route["handler"],
+      method: "get",
+      path: "/users",
+      handler: server.listUsers as Route["handler"],
     },
     {
       method: "get",
@@ -244,7 +228,7 @@ export interface ServerForPets<Req = unknown, Res = unknown> {
 }
 
 export interface ServerForUntagged<Req = unknown, Res = unknown> {
-  mixedContentTypes: (args: MixedContentTypesArgs<Req, Res>) => MixedContentTypesResult;
+  listUsers: (args: ListUsersArgs<Req, Res>) => ListUsersResult;
 }
 
 export interface ServerForStore<Req = unknown, Res = unknown> {
@@ -278,9 +262,9 @@ export function registerRouteHandlersByTag<Req, Res>(tag: Tag, server: Partial<S
       break;
     case null:
       routes.push({
-        method: "post",
-        path: "/pet/{petId}/mixed-content-types",
-        handler: server.mixedContentTypes as Route["handler"],
+        method: "get",
+        path: "/users",
+        handler: server.listUsers as Route["handler"],
       });
       break;
     case "store":