typespec-autorest - @Openapi.extension emit schema for Types

.chronus/changes/openapi-extension-emit-schema-2025-2-4-10-35-45.md

@@ -0,0 +1,24 @@
+---
+changeKind: breaking
+packages:
+  - "@azure-tools/typespec-autorest"
+---
+
+Updates the `@extension` behavior to emit schemas for passed in Types. Values will continue to be emitted as raw data. Model and Tuple expressions that were previously treated as Values are now treated as Types.
+
+Now the following TypeSpec:
+```tsp
+@OpenAPI.extension("x-value", "custom value")
+@OpenAPI.extension("x-schema", typeof "custom value")
+model Foo {}
+```
+emits the following schema:
+```yaml
+Foo:
+  type: object
+  x-value: custom value
+  x-schema:
+    type: string
+    enum:
+      - custom value
+```

packages/typespec-autorest/src/openapi.ts

@@ -94,6 +94,7 @@ import {
   isStringType,
   isTemplateDeclaration,
   isTemplateDeclarationOrInstance,
+  isType,
   isVoidType,
   joinPaths,
   navigateTypesInNamespace,
@@ -2133,7 +2134,15 @@ export async function getOpenAPIForService(
     }
     if (extensions) {
       for (const key of extensions.keys()) {
-        emitObject[key] = extensions.get(key);
+        const value = extensions.get(key);
+        if (isType(value)) {
+          emitObject[key] = getSchemaForType(value, {
+            ignoreMetadataAnnotations: false,
+            visibility: Visibility.All,
+          });
+        } else {
+          emitObject[key] = extensions.get(key);
+        }
       }
     }
   }

packages/typespec-autorest/test/openapi-output.test.ts

@@ -829,6 +829,80 @@ describe("typespec-autorest: extension decorator", () => {
     strictEqual(oapi.parameters.PetId["x-parameter-extension"], "foobaz");
   });
 
+  it("emits schemas for Types", async () => {
+    const oapi = await openApiFor(`
+    @extension("x-model-expression", { name: string })
+    @extension("x-array", string[])
+    @extension("x-model-template", Collection<string>)
+    @extension("x-string-literal", typeof "hi")
+    model Foo {}
+    model Collection<Item> {
+      size: int32;
+      item: Item[];
+    }
+    `);
+    const Foo = oapi.definitions.Foo;
+    ok(Foo);
+    deepStrictEqual(Foo["x-model-expression"], {
+      type: "object",
+      required: ["name"],
+      properties: {
+        name: {
+          type: "string",
+        },
+      },
+    });
+    deepStrictEqual(Foo["x-array"], {
+      items: { type: "string" },
+      type: "array",
+    });
+    deepStrictEqual(Foo["x-model-template"], {
+      properties: {
+        item: {
+          items: {
+            type: "string",
+          },
+          type: "array",
+        },
+        size: {
+          format: "int32",
+          type: "integer",
+        },
+      },
+      required: ["size", "item"],
+      type: "object",
+    });
+    deepStrictEqual(Foo["x-string-literal"], {
+      type: "string",
+      enum: ["hi"],
+      "x-ms-enum": {
+        modelAsString: false,
+      },
+    });
+  });
+
+  it("emits raw data for Values", async () => {
+    const oapi = await openApiFor(`
+    @extension("x-object-value", #{ name: "TypeSpec" })
+    @extension("x-tuple", #[ 1 ])
+    @extension("x-string-literal", "hi")
+    model Foo {}
+    model Collection<Item> {
+      size: int32;
+      item: Item[];
+    }
+
+    model Thing {
+      name: string;
+    }
+    `);
+    const Foo = oapi.definitions.Foo;
+    ok(Foo);
+    deepStrictEqual(Foo["x-object-value"], { name: "TypeSpec" });
+    deepStrictEqual(Foo["x-tuple"], [1]);
+    deepStrictEqual(Foo["x-string-literal"], "hi");
+  });
+
   it("support x-ms-identifiers with null array ", async () => {
     const oapi = await openApiFor(
       `