@typespec/http-specs 0.37.2

package/specs/type/model/inheritance/nested-discriminator/mockapi.ts

@@ -0,0 +1,150 @@
+import { json, MockRequest, passOnSuccess, ScenarioMockApi } from "@typespec/spec-api";
+
+export const Scenarios: Record<string, ScenarioMockApi> = {};
+
+const validPolymorphicBody = {
+  age: 1,
+  kind: "shark",
+  sharktype: "goblin",
+};
+const validRecursiveBody = {
+  age: 1,
+  kind: "salmon",
+  partner: {
+    age: 2,
+    kind: "shark",
+    sharktype: "saw",
+  },
+  friends: [
+    {
+      age: 2,
+      kind: "salmon",
+      partner: {
+        age: 3,
+        kind: "salmon",
+      },
+      hate: {
+        key1: {
+          age: 4,
+          kind: "salmon",
+        },
+        key2: {
+          age: 2,
+          kind: "shark",
+          sharktype: "goblin",
+        },
+      },
+    },
+    {
+      age: 3,
+      kind: "shark",
+      sharktype: "goblin",
+    },
+  ],
+  hate: {
+    key3: {
+      age: 3,
+      kind: "shark",
+      sharktype: "saw",
+    },
+    key4: {
+      age: 2,
+      kind: "salmon",
+      friends: [
+        {
+          age: 1,
+          kind: "salmon",
+        },
+        {
+          age: 4,
+          kind: "shark",
+          sharktype: "goblin",
+        },
+      ],
+    },
+  },
+};
+Scenarios.Type_Model_Inheritance_NestedDiscriminator_getModel = passOnSuccess({
+  uri: "/type/model/inheritance/nested-discriminator/model",
+  method: "get",
+  request: {},
+  response: {
+    status: 200,
+    body: json(validPolymorphicBody),
+  },
+  handler: (req: MockRequest) => {
+    return { status: 200, body: json(validPolymorphicBody) };
+  },
+  kind: "MockApiDefinition",
+});
+Scenarios.Type_Model_Inheritance_NestedDiscriminator_putModel = passOnSuccess({
+  uri: "/type/model/inheritance/nested-discriminator/model",
+  method: "put",
+  request: {
+    body: validPolymorphicBody,
+  },
+  response: {
+    status: 204,
+  },
+  handler: (req: MockRequest) => {
+    req.expect.bodyEquals(validPolymorphicBody);
+    return { status: 204 };
+  },
+  kind: "MockApiDefinition",
+});
+
+Scenarios.Type_Model_Inheritance_NestedDiscriminator_getRecursiveModel = passOnSuccess({
+  uri: "/type/model/inheritance/nested-discriminator/recursivemodel",
+  method: "get",
+  request: {},
+  response: {
+    status: 200,
+    body: json(validRecursiveBody),
+  },
+  handler: (req: MockRequest) => {
+    return { status: 200, body: json(validRecursiveBody) };
+  },
+  kind: "MockApiDefinition",
+});
+Scenarios.Type_Model_Inheritance_NestedDiscriminator_putRecursiveModel = passOnSuccess({
+  uri: "/type/model/inheritance/nested-discriminator/recursivemodel",
+  method: "put",
+  request: {
+    body: validRecursiveBody,
+  },
+  response: {
+    status: 204,
+  },
+  handler: (req: MockRequest) => {
+    req.expect.bodyEquals(validRecursiveBody);
+    return { status: 204 };
+  },
+  kind: "MockApiDefinition",
+});
+
+Scenarios.Type_Model_Inheritance_NestedDiscriminator_getMissingDiscriminator = passOnSuccess({
+  uri: "/type/model/inheritance/nested-discriminator/missingdiscriminator",
+  method: "get",
+  request: {},
+  response: {
+    status: 200,
+    body: json({ age: 1 }),
+  },
+  handler: (req: MockRequest) => {
+    return { status: 200, body: json({ age: 1 }) };
+  },
+  kind: "MockApiDefinition",
+});
+Scenarios.Type_Model_Inheritance_NestedDiscriminator_getWrongDiscriminator = passOnSuccess({
+  uri: "/type/model/inheritance/nested-discriminator/wrongdiscriminator",
+  method: "get",
+  request: {},
+  response: {
+    status: 200,
+    body: json({ age: 1, kind: "wrongKind" }),
+  },
+  handler: (req: MockRequest) => {
+    return { status: 200, body: json({ age: 1, kind: "wrongKind" }) };
+  },
+  kind: "MockApiDefinition",
+});

package/specs/type/model/inheritance/not-discriminated/main.tsp

@@ -0,0 +1,53 @@
+import "@typespec/http";
+import "@typespec/spec-lib";
+
+using TypeSpec.Http;
+
+@doc("Illustrates not-discriminated inheritance model.")
+@scenarioService("/type/model/inheritance/not-discriminated")
+namespace Type.Model.Inheritance.NotDiscriminated;
+
+@doc("This is base model for not-discriminated normal multiple levels inheritance.")
+model Pet {
+  name: string;
+}
+
+@doc("The second level model in the normal multiple levels inheritance.")
+model Cat extends Pet {
+  age: int32;
+}
+
+@doc("The third level model in the normal multiple levels inheritance.")
+model Siamese extends Cat {
+  smart: boolean;
+}
+
+@scenario
+@scenarioDoc("""
+  Generate and send model.
+  Expected input body:
+  ```json
+  {"name": "abc", "age": 32, "smart": true}
+  ```
+  """)
+@route("/valid")
+@post
+op postValid(@body input: Siamese): NoContentResponse;
+
+@scenario
+@scenarioDoc("""
+  Generate and receive model.
+  Expected response body:
+  ```json
+  {"name": "abc", "age": 32, "smart": true}
+  ```
+  """)
+@route("/valid")
+@get
+op getValid(): Siamese;
+
+@scenario
+@scenarioDoc("Generate, send, and receive round-trip bottom model.")
+@route("/valid")
+@put
+op putValid(@body input: Siamese): Siamese;

package/specs/type/model/inheritance/not-discriminated/mockapi.ts

@@ -0,0 +1,49 @@
+import { json, MockRequest, passOnSuccess, ScenarioMockApi } from "@typespec/spec-api";
+
+export const Scenarios: Record<string, ScenarioMockApi> = {};
+
+const inheritanceValidBody = { name: "abc", age: 32, smart: true };
+
+Scenarios.Type_Model_Inheritance_NotDiscriminated_postValid = passOnSuccess({
+  uri: "/type/model/inheritance/not-discriminated/valid",
+  method: "post",
+  request: {
+    body: inheritanceValidBody,
+  },
+  response: {
+    status: 204,
+  },
+  handler: (req: MockRequest) => {
+    req.expect.bodyEquals(inheritanceValidBody);
+    return { status: 204 };
+  },
+  kind: "MockApiDefinition",
+});
+Scenarios.Type_Model_Inheritance_NotDiscriminated_getValid = passOnSuccess({
+  uri: "/type/model/inheritance/not-discriminated/valid",
+  method: "get",
+  request: {},
+  response: {
+    status: 200,
+    body: json(inheritanceValidBody),
+  },
+  handler: (req: MockRequest) => {
+    return { status: 200, body: json(inheritanceValidBody) };
+  },
+  kind: "MockApiDefinition",
+});
+Scenarios.Type_Model_Inheritance_NotDiscriminated_putValid = passOnSuccess({
+  uri: "/type/model/inheritance/not-discriminated/valid",
+  method: "put",
+  request: {
+    body: inheritanceValidBody,
+  },
+  response: {
+    status: 200,
+    body: json(inheritanceValidBody),
+  },
+  handler: (req: MockRequest) => {
+    return { status: 200, body: json(req.body) };
+  },
+  kind: "MockApiDefinition",
+});

package/specs/type/model/inheritance/recursive/main.tsp

@@ -0,0 +1,70 @@
+import "@typespec/http";
+import "@typespec/spec-lib";
+
+using TypeSpec.Http;
+
+@doc("Illustrates inheritance recursion")
+@scenarioService("/type/model/inheritance/recursive")
+namespace Type.Model.Inheritance.Recursive;
+
+@doc("extension")
+model Extension extends Element {
+  level: int8;
+}
+
+@doc("element")
+model Element {
+  extension?: Extension[];
+}
+
+@scenario
+@scenarioDoc("""
+  Send a PUT request with the following body:
+  Expected input body:
+  ```json
+  {
+    "level": 0,
+    "extension": [
+      {
+        "level": 1,
+        "extension": [
+          {
+            "level": 2
+          }
+        ]
+      },
+      {
+        "level": 1
+      }
+    ]
+  }
+  ```
+  """)
+@put
+op put(@body input: Extension): void;
+
+@scenario
+@scenarioDoc("""
+  Send a GET request which returns the following body:
+  Expected response body:
+  ```json
+  {
+    "level": 0,
+    "extension": [
+      {
+        "level": 1,
+        "extension": [
+          {
+            "level": 2
+          }
+        ]
+      },
+      {
+        "level": 1
+      }
+    ]
+  }
+  ```
+  """)
+@get
+op get(): Extension;

package/specs/type/model/inheritance/recursive/mockapi.ts

@@ -0,0 +1,48 @@
+import { json, MockRequest, passOnSuccess, ScenarioMockApi } from "@typespec/spec-api";
+
+export const Scenarios: Record<string, ScenarioMockApi> = {};
+
+const body = {
+  level: 0,
+  extension: [
+    {
+      level: 1,
+      extension: [
+        {
+          level: 2,
+        },
+      ],
+    },
+    {
+      level: 1,
+    },
+  ],
+};
+Scenarios.Type_Model_Inheritance_Recursive_put = passOnSuccess({
+  uri: "/type/model/inheritance/recursive",
+  method: "put",
+  request: {
+    body: body,
+  },
+  response: {
+    status: 204,
+  },
+  handler: (req: MockRequest) => {
+    req.expect.bodyEquals(body);
+    return { status: 204 };
+  },
+  kind: "MockApiDefinition",
+});
+Scenarios.Type_Model_Inheritance_Recursive_get = passOnSuccess({
+  uri: "/type/model/inheritance/recursive",
+  method: "get",
+  request: {},
+  response: {
+    status: 200,
+    body: json(body),
+  },
+  handler: (req: MockRequest) => {
+    return { status: 200, body: json(body) };
+  },
+  kind: "MockApiDefinition",
+});

package/specs/type/model/inheritance/single-discriminator/main.tsp

@@ -0,0 +1,171 @@
+import "@typespec/http";
+import "@typespec/spec-lib";
+
+using TypeSpec.Http;
+
+@doc("Illustrates inheritance with single discriminator.")
+@scenarioService("/type/model/inheritance/single-discriminator")
+namespace Type.Model.Inheritance.SingleDiscriminator;
+
+@doc("This is base model for polymorphic single level inheritance with a discriminator.")
+@discriminator("kind")
+model Bird {
+  kind: string;
+  wingspan: int32;
+}
+
+@doc("The second level model in polymorphic single level inheritance.")
+model SeaGull extends Bird {
+  kind: "seagull";
+}
+
+@doc("The second level model in polymorphic single level inheritance.")
+model Sparrow extends Bird {
+  kind: "sparrow";
+}
+
+@doc("The second level model in polymorphic single level inheritance.")
+model Goose extends Bird {
+  kind: "goose";
+}
+
+@doc("The second level model in polymorphic single levels inheritance which contains references to other polymorphic instances.")
+model Eagle extends Bird {
+  kind: "eagle";
+  friends?: Bird[];
+  hate?: Record<Bird>;
+  partner?: Bird;
+}
+
+@doc("Define a base class in the legacy way. Discriminator property is not explicitly defined in the model.")
+@discriminator("kind")
+model Dinosaur {
+  size: int32;
+}
+
+@doc("The second level legacy model in polymorphic single level inheritance.")
+model TRex extends Dinosaur {
+  kind: "t-rex";
+}
+
+@scenario
+@route("/model")
+@scenarioDoc("""
+  Generate and receive polymorphic model in single level inheritance with 1 discriminator.
+  Expected response body:
+  ```json
+  {"wingspan": 1, "kind": "sparrow"}
+  ```
+  """)
+@get
+op getModel(): Bird;
+
+@scenario
+@route("/model")
+@scenarioDoc("""
+  Generate and send polymorphic model in single level inheritance with 1 discriminator.
+  Expected input body:
+  ```json
+  {"wingspan": 1, "kind": "sparrow"}
+  ```
+  """)
+@put
+op putModel(@body input: Bird): NoContentResponse;
+
+@scenario
+@route("/recursivemodel")
+@scenarioDoc("""
+  Generate and receive polymorphic models has collection and dictionary properties referring to other polymorphic models.
+  Expected response body:
+  ```json
+  {
+    "wingspan": 5,
+    "kind": "eagle",
+    "partner": {
+      "wingspan": 2,
+      "kind": "goose"
+    },
+    "friends": [
+      {
+        "wingspan": 2,
+        "kind": "seagull"
+      }
+    ],
+    "hate": {
+      "key3": {
+        "wingspan": 1,
+        "kind": "sparrow"
+      }
+    }
+  }
+  ```
+  """)
+@get
+op getRecursiveModel(): Bird;
+
+@scenario
+@route("/recursivemodel")
+@scenarioDoc("""
+  Generate and send polymorphic models has collection and dictionary properties referring to other polymorphic models.
+  Expected input body:
+  ```json
+  {
+    "wingspan": 5,
+    "kind": "eagle",
+    "partner": {
+      "wingspan": 2,
+      "kind": "goose"
+    },
+    "friends": [
+      {
+        "wingspan": 2,
+        "kind": "seagull"
+      }
+    ],
+    "hate": {
+      "key3": {
+        "wingspan": 1,
+        "kind": "sparrow"
+      }
+    }
+  }
+  ```
+  """)
+@put
+op putRecursiveModel(@body input: Bird): NoContentResponse;
+
+@scenario
+@route("/missingdiscriminator")
+@scenarioDoc("""
+  Get a model omitting the discriminator.
+  Expected response body:
+  ```json
+  {"wingspan": 1}
+  ```
+  """)
+@get
+op getMissingDiscriminator(): Bird;
+
+@scenario
+@route("/wrongdiscriminator")
+@scenarioDoc("""
+  Get a model containing discriminator value never defined.
+  Expected response body:
+  ```json
+  {"wingspan": 1, "kind": "wrongKind" }
+  ```
+  """)
+@get
+op getWrongDiscriminator(): Bird;
+
+@scenario
+@route("/legacy-model")
+@scenarioDoc("""
+  Generate and receive polymorphic model defined in legacy way.
+  Expected response body:
+  ```json
+  {"size": 20, "kind": "t-rex"}
+  ```
+  """)
+@get
+op getLegacyModel(): Dinosaur;

package/specs/type/model/inheritance/single-discriminator/mockapi.ts

@@ -0,0 +1,126 @@
+import { json, MockRequest, passOnSuccess, ScenarioMockApi } from "@typespec/spec-api";
+
+export const Scenarios: Record<string, ScenarioMockApi> = {};
+
+const validPolymorphicBody = {
+  wingspan: 1,
+  kind: "sparrow",
+};
+const validRecursiveBody = {
+  wingspan: 5,
+  kind: "eagle",
+  partner: {
+    wingspan: 2,
+    kind: "goose",
+  },
+  friends: [
+    {
+      wingspan: 2,
+      kind: "seagull",
+    },
+  ],
+  hate: {
+    key3: {
+      wingspan: 1,
+      kind: "sparrow",
+    },
+  },
+};
+Scenarios.Type_Model_Inheritance_SingleDiscriminator_getModel = passOnSuccess({
+  uri: "/type/model/inheritance/single-discriminator/model",
+  method: "get",
+  request: {},
+  response: {
+    status: 200,
+    body: json(validPolymorphicBody),
+  },
+  handler: (req: MockRequest) => {
+    return { status: 200, body: json(validPolymorphicBody) };
+  },
+  kind: "MockApiDefinition",
+});
+Scenarios.Type_Model_Inheritance_SingleDiscriminator_putModel = passOnSuccess({
+  uri: "/type/model/inheritance/single-discriminator/model",
+  method: "put",
+  request: {
+    body: validPolymorphicBody,
+  },
+  response: {
+    status: 204,
+  },
+  handler: (req: MockRequest) => {
+    req.expect.bodyEquals(validPolymorphicBody);
+    return { status: 204 };
+  },
+  kind: "MockApiDefinition",
+});
+
+Scenarios.Type_Model_Inheritance_SingleDiscriminator_getRecursiveModel = passOnSuccess({
+  uri: "/type/model/inheritance/single-discriminator/recursivemodel",
+  method: "get",
+  request: {},
+  response: {
+    status: 200,
+    body: json(validRecursiveBody),
+  },
+  handler: (req: MockRequest) => {
+    return { status: 200, body: json(validRecursiveBody) };
+  },
+  kind: "MockApiDefinition",
+});
+Scenarios.Type_Model_Inheritance_SingleDiscriminator_putRecursiveModel = passOnSuccess({
+  uri: "/type/model/inheritance/single-discriminator/recursivemodel",
+  method: "put",
+  request: {
+    body: validRecursiveBody,
+  },
+  response: {
+    status: 204,
+  },
+  handler: (req: MockRequest) => {
+    req.expect.bodyEquals(validRecursiveBody);
+    return { status: 204 };
+  },
+  kind: "MockApiDefinition",
+});
+
+Scenarios.Type_Model_Inheritance_SingleDiscriminator_getMissingDiscriminator = passOnSuccess({
+  uri: "/type/model/inheritance/single-discriminator/missingdiscriminator",
+  method: "get",
+  request: {},
+  response: {
+    status: 200,
+    body: json({ wingspan: 1 }),
+  },
+  handler: (req: MockRequest) => {
+    return { status: 200, body: json({ wingspan: 1 }) };
+  },
+  kind: "MockApiDefinition",
+});
+
+Scenarios.Type_Model_Inheritance_SingleDiscriminator_getWrongDiscriminator = passOnSuccess({
+  uri: "/type/model/inheritance/single-discriminator/wrongdiscriminator",
+  method: "get",
+  request: {},
+  response: {
+    status: 200,
+    body: json({ wingspan: 1, kind: "wrongKind" }),
+  },
+  handler: (req: MockRequest) => {
+    return { status: 200, body: json({ wingspan: 1, kind: "wrongKind" }) };
+  },
+  kind: "MockApiDefinition",
+});
+Scenarios.Type_Model_Inheritance_SingleDiscriminator_getLegacyModel = passOnSuccess({
+  uri: "/type/model/inheritance/single-discriminator/legacy-model",
+  method: "get",
+  request: {},
+  response: {
+    status: 200,
+    body: json({ size: 20, kind: "t-rex" }),
+  },
+  handler: (req: MockRequest) => {
+    return { status: 200, body: json({ size: 20, kind: "t-rex" }) };
+  },
+  kind: "MockApiDefinition",
+});