@typespec/http-specs 0.1.0-alpha.0

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

@@ -0,0 +1,39 @@
+import { json, 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,
+  },
+  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),
+  },
+  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),
+  },
+  kind: "MockApiDefinition",
+});

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

@@ -0,0 +1,71 @@
+import "@typespec/http";
+import "@typespec/spector";
+
+using Http;
+using Spector;
+
+@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,41 @@
+import { json, 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,
+  },
+  kind: "MockApiDefinition",
+});
+Scenarios.Type_Model_Inheritance_Recursive_get = passOnSuccess({
+  uri: "/type/model/inheritance/recursive",
+  method: "get",
+  request: {},
+  response: {
+    status: 200,
+    body: json(body),
+  },
+  kind: "MockApiDefinition",
+});

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

@@ -0,0 +1,172 @@
+import "@typespec/http";
+import "@typespec/spector";
+
+using Http;
+using Spector;
+
+@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,103 @@
+import { json, 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),
+  },
+  kind: "MockApiDefinition",
+});
+Scenarios.Type_Model_Inheritance_SingleDiscriminator_putModel = passOnSuccess({
+  uri: "/type/model/inheritance/single-discriminator/model",
+  method: "put",
+  request: {
+    body: validPolymorphicBody,
+  },
+  response: {
+    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),
+  },
+  kind: "MockApiDefinition",
+});
+Scenarios.Type_Model_Inheritance_SingleDiscriminator_putRecursiveModel = passOnSuccess({
+  uri: "/type/model/inheritance/single-discriminator/recursivemodel",
+  method: "put",
+  request: {
+    body: validRecursiveBody,
+  },
+  response: {
+    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 }),
+  },
+  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" }),
+  },
+  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" }),
+  },
+  kind: "MockApiDefinition",
+});

package/specs/type/model/templated/main.tsp

@@ -0,0 +1,130 @@
+import "@typespec/http";
+import "@typespec/spector";
+
+using Http;
+using Spector;
+
+/**
+ * Illustrates the model templated cases. There is a base templated type and an instantiated type extending from it.
+ */
+@scenarioService("/type/model/templated")
+namespace Type.Model.Templated;
+
+@friendlyName("{name}Type", T)
+model NumericType<T extends numeric> {
+  /**
+   * An array of numeric values.
+   */
+  values: T[];
+
+  value: T;
+}
+
+/**
+ * An instantiated type representing int32 values type.
+ */
+model Int32ValuesType extends NumericType<int32> {
+  /**
+   * The Kind of the Int32ValuesType.
+   */
+  kind: "Int32Values";
+}
+
+/**
+ * An instantiated type representing float32 values type.
+ */
+model Float32ValuesType extends NumericType<float32> {
+  /**
+   * The Kind of the Float32ValuesType.
+   */
+  kind: "Float32Values";
+}
+
+@scenario
+@scenarioDoc("""
+  Expected input body:
+  ```json
+  {
+    "kind": "Int32Values",
+    "values": 
+    [
+      1234
+    ],
+    "value": 1234
+  }
+  ```
+  
+  Expected response body:
+  ```json
+  {
+    "values": 
+    [
+      1234
+    ],
+    "value": 1234
+  }
+  ```
+  """)
+@route("/numericType")
+@put
+op numericType(@body input: NumericType<int32>): NumericType<int32>;
+
+@scenario
+@scenarioDoc("""
+  Expected input body:
+  ```json
+  {
+    "kind": "Float32Values",
+    "values": 
+    [
+      0.5
+    ],
+    "value": 0.5
+  }
+  ```
+  
+  Expected response body:
+  ```json
+  {
+    "kind": "Float32Values",
+    "values": 
+    [
+      0.5
+    ],
+    "value": 0.5
+  }
+  ```
+  """)
+@route("/float32ValuesType")
+@put
+op float32Type(@body input: Float32ValuesType): Float32ValuesType;
+
+@scenario
+@scenarioDoc("""
+  Expected input body:
+  ```json
+  {
+    "kind": "Int32Values",
+    "values": 
+    [
+      1234
+    ],
+    "value": 1234
+  }
+  ```
+  
+  Expected response body:
+  ```json
+  {
+    "kind": "Int32Values",
+    "values": 
+    [
+      1234
+    ],
+    "value": 1234
+  }
+  ```
+  """)
+@route("/int32ValuesType")
+@put
+op int32Type(@body input: Int32ValuesType): Int32ValuesType;

package/specs/type/model/templated/mockapi.ts

@@ -0,0 +1,66 @@
+import { json, passOnSuccess, ScenarioMockApi } from "@typespec/spec-api";
+
+export const Scenarios: Record<string, ScenarioMockApi> = {};
+
+Scenarios.Type_Model_Templated_numericType = passOnSuccess({
+  uri: "/type/model/templated/numericType",
+  method: "put",
+  request: {
+    body: {
+      kind: "Int32Values",
+      values: [1234],
+      value: 1234,
+    },
+  },
+  response: {
+    status: 200,
+    body: json({
+      kind: "Int32Values",
+      values: [1234],
+      value: 1234,
+    }),
+  },
+  kind: "MockApiDefinition",
+});
+
+Scenarios.Type_Model_Templated_float32Type = passOnSuccess({
+  uri: "/type/model/templated/float32ValuesType",
+  method: "put",
+  request: {
+    body: {
+      kind: "Float32Values",
+      values: [0.5],
+      value: 0.5,
+    },
+  },
+  response: {
+    status: 200,
+    body: json({
+      kind: "Float32Values",
+      values: [0.5],
+      value: 0.5,
+    }),
+  },
+  kind: "MockApiDefinition",
+});
+
+Scenarios.Type_Model_Templated_int32Type = passOnSuccess({
+  uri: "/type/model/templated/int32ValuesType",
+  method: "put",
+  request: {
+    body: {
+      kind: "Int32Values",
+      values: [1234],
+      value: 1234,
+    },
+  },
+  response: {
+    status: 200,
+    body: json({
+      kind: "Int32Values",
+      values: [1234],
+      value: 1234,
+    }),
+  },
+  kind: "MockApiDefinition",
+});

package/specs/type/model/usage/main.tsp

@@ -0,0 +1,49 @@
+import "@typespec/http";
+import "@typespec/spector";
+
+using Http;
+using Spector;
+
+/**
+ * Those tests are meant to test different behavior of records if they are used as input, output or both.
+ * This is something that might not matter in your emitter.
+ *
+ * This is valuable if you for example only decide to create a public constructor if a model is used as input.
+ */
+@doc("Illustrates usage of Record in different places(Operation parameters, return type or both).")
+@scenarioService("/type/model/usage")
+namespace Type.Model.Usage;
+
+alias RecordBase = {
+  requiredProp: string;
+};
+
+@doc("Record used in operation parameters")
+model InputRecord {
+  ...RecordBase;
+}
+
+@doc("Record used in operation return type")
+model OutputRecord {
+  ...RecordBase;
+}
+
+@doc("Record used both as operation parameter and return type")
+model InputOutputRecord {
+  ...RecordBase;
+}
+
+@scenario
+@scenarioDoc("Send a POST request with the following body {requiredProp: \"example-value\"}")
+@route("/input")
+op input(@body input: InputRecord): void;
+
+@scenario
+@scenarioDoc("Send a GET request which return the following body {requiredProp: \"example-value\"}")
+@route("/output")
+op output(): OutputRecord;
+
+@scenario
+@scenarioDoc("Send a POST request which return the following body {requiredProp: \"example-value\"} and return the same.")
+@route("/input-output")
+op inputAndOutput(@body body: InputOutputRecord): InputOutputRecord;