@typespec/http-specs 0.37.2

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

@@ -0,0 +1,130 @@
+import "@typespec/http";
+import "@typespec/spec-lib";
+
+using TypeSpec.Http;
+using Azure.ClientGenerator.Core;
+
+/**
+ * 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,102 @@
+import { json, MockRequest, 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,
+    }),
+  },
+  handler: (req: MockRequest) => {
+    const body = {
+      kind: "Int32Values",
+      values: [1234],
+      value: 1234,
+    };
+    req.expect.bodyEquals(body);
+    return {
+      status: 200,
+      body: json(body),
+    };
+  },
+  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,
+    }),
+  },
+  handler: (req: MockRequest) => {
+    const body = {
+      kind: "Float32Values",
+      values: [0.5],
+      value: 0.5,
+    };
+    req.expect.bodyEquals(body);
+    return {
+      status: 200,
+      body: json(body),
+    };
+  },
+  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,
+    }),
+  },
+  handler: (req: MockRequest) => {
+    const body = {
+      kind: "Int32Values",
+      values: [1234],
+      value: 1234,
+    };
+    req.expect.bodyEquals(body);
+    return {
+      status: 200,
+      body: json(body),
+    };
+  },
+  kind: "MockApiDefinition",
+});

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

@@ -0,0 +1,48 @@
+import "@typespec/http";
+import "@typespec/spec-lib";
+
+using TypeSpec.Http;
+
+/**
+ * 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;

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

@@ -0,0 +1,56 @@
+import { json, MockRequest, passOnSuccess, ScenarioMockApi } from "@typespec/spec-api";
+
+export const Scenarios: Record<string, ScenarioMockApi> = {};
+
+const body = { requiredProp: "example-value" };
+
+Scenarios.Type_Model_Usage_input = passOnSuccess({
+  uri: "/type/model/usage/input",
+  method: "post",
+  request: {
+    body: {
+      requiredProp: "example-value",
+    },
+  },
+  response: {
+    status: 204,
+  },
+  handler: (req: MockRequest) => {
+    req.expect.bodyEquals(body);
+    return { status: 204 };
+  },
+  kind: "MockApiDefinition",
+});
+
+Scenarios.Type_Model_Usage_output = passOnSuccess({
+  uri: "/type/model/usage/output",
+  method: "get",
+  request: {},
+  response: {
+    status: 200,
+    body: json(body),
+  },
+  handler: (req: MockRequest) => {
+    return { status: 200, body: json(body) };
+  },
+  kind: "MockApiDefinition",
+});
+
+Scenarios.Type_Model_Usage_inputAndOutput = passOnSuccess({
+  uri: "/type/model/usage/input-output",
+  method: "post",
+  request: {
+    body: {
+      requiredProp: "example-value",
+    },
+  },
+  response: {
+    status: 200,
+    body: json(body),
+  },
+  handler: (req: MockRequest) => {
+    req.expect.bodyEquals(body);
+    return { status: 200, body: json(body) };
+  },
+  kind: "MockApiDefinition",
+});

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

@@ -0,0 +1,152 @@
+import "@typespec/http";
+import "@typespec/spec-lib";
+
+using TypeSpec.Http;
+
+@doc("Illustrates models with visibility properties.")
+@scenarioService("/type/model/visibility")
+namespace Type.Model.Visibility;
+
+@doc("Output model with visibility properties.")
+model VisibilityModel {
+  @doc("Required string, illustrating a readonly property.")
+  @visibility("read")
+  readProp: string;
+
+  @doc("Required int32, illustrating a query property.")
+  @visibility("query")
+  queryProp: int32;
+
+  @doc("Required string[], illustrating a create property.")
+  @visibility("create")
+  createProp: string[];
+
+  @doc("Required int32[], illustrating a update property.")
+  @visibility("update")
+  updateProp: int32[];
+
+  @doc("Required bool, illustrating a delete property.")
+  @visibility("delete")
+  deleteProp: boolean;
+}
+
+/** RoundTrip model with readonly optional properties. */
+model ReadOnlyModel {
+  /** Optional readonly nullable int list. */
+  @visibility("read")
+  optionalNullableIntList?: int32[] | null;
+
+  /** Optional readonly string dictionary. */
+  @visibility("read")
+  optionalStringRecord?: Record<string>;
+}
+
+@scenario
+@scenarioDoc("""
+  Generate and receive output model with readonly properties.
+  Expected input body:
+  ```json
+  {
+    queryProp: 123,
+  }
+  ```
+  
+  Expected response body:
+  ```json
+  {
+    readProp: "abc",
+  }
+  ```
+  """)
+@get
+op getModel(@body input: VisibilityModel): {
+  @body
+  output: VisibilityModel;
+};
+
+@scenario
+@scenarioDoc("""
+  Generate abd send put model with write/create properties.
+  Expected input body:
+  ```json
+  {
+    queryProp: 123,
+  }
+  ```
+  """)
+@head
+op headModel(@body input: VisibilityModel): OkResponse;
+
+@scenario
+@scenarioDoc("""
+  Generate abd send put model with write/create/update properties.
+  Expected input body:
+  ```json
+  {
+    createProp: ["foo", "bar"],
+    updateProp: [1, 2],
+  }
+  ```
+  """)
+@put
+op putModel(@body input: VisibilityModel): void;
+
+@scenario
+@scenarioDoc("""
+  Generate abd send put model with write/update properties.
+  Expected input body:
+  ```json
+  {
+    updateProp: [1, 2],
+  }
+  ```
+  """)
+@patch
+op patchModel(@body input: VisibilityModel): void;
+
+@scenario
+@scenarioDoc("""
+  Generate abd send put model with write/create properties.
+  Expected input body:
+  ```json
+  {
+    createProp: ["foo", "bar"],
+  }
+  ```
+  """)
+@post
+op postModel(@body input: VisibilityModel): void;
+
+@scenario
+@scenarioDoc("""
+  Generate abd send put model with write/create properties.
+  Expected input body:
+  ```json
+  {
+    deleteProp: true,
+  }
+  ```
+  """)
+@delete
+op deleteModel(@body input: VisibilityModel): void;
+
+@route("/readonlyroundtrip")
+@scenario
+@scenarioDoc("""
+  Generate and receive output model with readonly properties.
+  
+  Expected input body:
+  ```json
+  {}
+  ```
+  
+  Expected response body:
+  ```json
+  {
+    optionalNullableIntList: [1, 2, 3],
+    optionalStringRecord: { k1: "value1", k2: "value2" },
+  }
+  ```
+  """)
+@put
+op putReadOnlyModel(@body input: ReadOnlyModel): ReadOnlyModel;

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

@@ -0,0 +1,139 @@
+import { json, MockRequest, passOnSuccess, ScenarioMockApi } from "@typespec/spec-api";
+
+export const Scenarios: Record<string, ScenarioMockApi> = {};
+
+function genData(keys: string[]): Record<string, any> {
+  const ret: Record<string, any> = {};
+  const fullData: Record<string, any> = {
+    readProp: "abc",
+    queryProp: 123,
+    createProp: ["foo", "bar"],
+    updateProp: [1, 2],
+    deleteProp: true,
+  };
+  for (const k of keys) {
+    if (k in fullData) {
+      ret[k] = fullData[k];
+    }
+  }
+  return ret;
+}
+const expectBody = {
+  optionalNullableIntList: [1, 2, 3],
+  optionalStringRecord: { k1: "value1", k2: "value2" },
+};
+Scenarios.Type_Model_Visibility_putReadOnlyModel = passOnSuccess({
+  uri: "/type/model/visibility/readonlyroundtrip",
+  method: "put",
+  request: {},
+  response: {
+    status: 200,
+    body: json(expectBody),
+  },
+  handler: (req: MockRequest) => {
+    req.expect.bodyEquals({});
+    return { status: 200, body: json(expectBody) };
+  },
+  kind: "MockApiDefinition",
+});
+Scenarios.Type_Model_Visibility_headModel = passOnSuccess({
+  uri: "/type/model/visibility",
+  method: "head",
+  request: {
+    body: { queryProp: 123 },
+  },
+  response: {
+    status: 200,
+  },
+  handler: (req: MockRequest) => {
+    req.expect.bodyEquals(genData(["queryProp"]));
+    return { status: 200 };
+  },
+  kind: "MockApiDefinition",
+});
+Scenarios.Type_Model_Visibility_getModel = passOnSuccess({
+  uri: "/type/model/visibility",
+  method: "get",
+  request: {
+    body: { queryProp: 123 },
+  },
+  response: {
+    status: 200,
+    body: json(genData(["readProp"])),
+  },
+  handler: (req: MockRequest) => {
+    req.expect.bodyEquals(genData(["queryProp"]));
+    return {
+      status: 200,
+      body: json(genData(["readProp"])),
+    };
+  },
+  kind: "MockApiDefinition",
+});
+Scenarios.Type_Model_Visibility_putModel = passOnSuccess({
+  uri: "/type/model/visibility",
+  method: "put",
+  request: {
+    body: {
+      createProp: ["foo", "bar"],
+      updateProp: [1, 2],
+    },
+  },
+  response: {
+    status: 204,
+  },
+  handler: (req: MockRequest) => {
+    req.expect.bodyEquals(genData(["createProp", "updateProp"]));
+    return { status: 204 };
+  },
+  kind: "MockApiDefinition",
+});
+Scenarios.Type_Model_Visibility_patchModel = passOnSuccess({
+  uri: "/type/model/visibility",
+  method: "patch",
+  request: {
+    body: {
+      updateProp: [1, 2],
+    },
+  },
+  response: {
+    status: 204,
+  },
+  handler: (req: MockRequest) => {
+    req.expect.bodyEquals(genData(["updateProp"]));
+    return { status: 204 };
+  },
+  kind: "MockApiDefinition",
+});
+Scenarios.Type_Model_Visibility_postModel = passOnSuccess({
+  uri: "/type/model/visibility",
+  method: "post",
+  request: {
+    body: {
+      createProp: ["foo", "bar"],
+    },
+  },
+  response: {
+    status: 204,
+  },
+  handler: (req: MockRequest) => {
+    req.expect.bodyEquals(genData(["createProp"]));
+    return { status: 204 };
+  },
+  kind: "MockApiDefinition",
+});
+Scenarios.Type_Model_Visibility_deleteModel = passOnSuccess({
+  uri: "/type/model/visibility",
+  method: "delete",
+  request: {
+    body: { deleteProp: true },
+  },
+  response: {
+    status: 204,
+  },
+  handler: (req: MockRequest) => {
+    req.expect.bodyEquals(genData(["deleteProp"]));
+    return { status: 204 };
+  },
+  kind: "MockApiDefinition",
+});