@typespec/http-specs 0.1.0-alpha.0

package/specs/type/property/optionality/mockapi.ts

@@ -0,0 +1,296 @@
+import { json, passOnSuccess, ScenarioMockApi } from "@typespec/spec-api";
+
+export const Scenarios: Record<string, ScenarioMockApi> = {};
+
+function createServerTests(url: string, value: unknown) {
+  return {
+    get: passOnSuccess({
+      uri: url,
+      method: `get`,
+      request: {},
+      response: {
+        status: 200,
+        body: json(value),
+      },
+      kind: "MockApiDefinition",
+    }),
+    put: passOnSuccess({
+      uri: url,
+      method: `put`,
+      request: {
+        body: value,
+      },
+      response: {
+        status: 204,
+      },
+      kind: "MockApiDefinition",
+    }),
+  };
+}
+
+const Type_Property_Optional_String_Default = createServerTests(
+  `/type/property/optional/string/default`,
+  {},
+);
+const Type_Property_Optional_String_All = createServerTests(`/type/property/optional/string/all`, {
+  property: "hello",
+});
+Scenarios.Type_Property_Optional_String_getDefault = Type_Property_Optional_String_Default.get;
+Scenarios.Type_Property_Optional_String_putDefault = Type_Property_Optional_String_Default.put;
+Scenarios.Type_Property_Optional_String_getAll = Type_Property_Optional_String_All.get;
+Scenarios.Type_Property_Optional_String_putAll = Type_Property_Optional_String_All.put;
+
+const Type_Property_Optional_Bytes_Default = createServerTests(
+  `/type/property/optional/bytes/default`,
+  {},
+);
+const Type_Property_Optional_Bytes_All = createServerTests(`/type/property/optional/bytes/all`, {
+  property: "aGVsbG8sIHdvcmxkIQ==",
+});
+Scenarios.Type_Property_Optional_Bytes_getDefault = Type_Property_Optional_Bytes_Default.get;
+Scenarios.Type_Property_Optional_Bytes_putDefault = Type_Property_Optional_Bytes_Default.put;
+Scenarios.Type_Property_Optional_Bytes_getAll = Type_Property_Optional_Bytes_All.get;
+Scenarios.Type_Property_Optional_Bytes_putAll = Type_Property_Optional_Bytes_All.put;
+
+const Type_Property_Optional_DateTime_Default = createServerTests(
+  `/type/property/optional/datetime/default`,
+  {},
+);
+const Type_Property_Optional_DateTime_All = createServerTests(
+  `/type/property/optional/datetime/all`,
+  {
+    property: "2022-08-26T18:38:00Z",
+  },
+);
+Scenarios.Type_Property_Optional_Datetime_getDefault = Type_Property_Optional_DateTime_Default.get;
+Scenarios.Type_Property_Optional_Datetime_putDefault = Type_Property_Optional_DateTime_Default.put;
+Scenarios.Type_Property_Optional_Datetime_getAll = Type_Property_Optional_DateTime_All.get;
+Scenarios.Type_Property_Optional_Datetime_putAll = Type_Property_Optional_DateTime_All.put;
+
+const Type_Property_Optional_Duration_Default = createServerTests(
+  `/type/property/optional/duration/default`,
+  {},
+);
+const Type_Property_Optional_Duration_All = createServerTests(
+  `/type/property/optional/duration/all`,
+  {
+    property: "P123DT22H14M12.011S",
+  },
+);
+
+Scenarios.Type_Property_Optional_Duration_getDefault = Type_Property_Optional_Duration_Default.get;
+Scenarios.Type_Property_Optional_Duration_putDefault = Type_Property_Optional_Duration_Default.put;
+Scenarios.Type_Property_Optional_Duration_getAll = Type_Property_Optional_Duration_All.get;
+Scenarios.Type_Property_Optional_Duration_putAll = Type_Property_Optional_Duration_All.put;
+
+const Type_Property_Optional_PlainDate_Default = createServerTests(
+  `/type/property/optional/plainDate/default`,
+  {},
+);
+const Type_Property_Optional_PlainDate_All = createServerTests(
+  `/type/property/optional/plainDate/all`,
+  {
+    property: "2022-12-12",
+  },
+);
+
+Scenarios.Type_Property_Optional_PlainDate_getDefault =
+  Type_Property_Optional_PlainDate_Default.get;
+Scenarios.Type_Property_Optional_PlainDate_putDefault =
+  Type_Property_Optional_PlainDate_Default.put;
+Scenarios.Type_Property_Optional_PlainDate_getAll = Type_Property_Optional_PlainDate_All.get;
+Scenarios.Type_Property_Optional_PlainDate_putAll = Type_Property_Optional_PlainDate_All.put;
+
+const Type_Property_Optional_PlainTime_Default = createServerTests(
+  `/type/property/optional/plainTime/default`,
+  {},
+);
+const Type_Property_Optional_PlainTime_All = createServerTests(
+  `/type/property/optional/plainTime/all`,
+  {
+    property: "13:06:12",
+  },
+);
+Scenarios.Type_Property_Optional_PlainTime_getDefault =
+  Type_Property_Optional_PlainTime_Default.get;
+Scenarios.Type_Property_Optional_PlainTime_putDefault =
+  Type_Property_Optional_PlainTime_Default.put;
+Scenarios.Type_Property_Optional_PlainTime_getAll = Type_Property_Optional_PlainTime_All.get;
+Scenarios.Type_Property_Optional_PlainTime_putAll = Type_Property_Optional_PlainTime_All.put;
+
+const Type_Property_Optional_Collections_Bytes_Default = createServerTests(
+  `/type/property/optional/collections/bytes/default`,
+  {},
+);
+const Type_Property_Optional_Collections_Bytes_All = createServerTests(
+  `/type/property/optional/collections/bytes/all`,
+  { property: ["aGVsbG8sIHdvcmxkIQ==", "aGVsbG8sIHdvcmxkIQ=="] },
+);
+
+Scenarios.Type_Property_Optional_CollectionsByte_getDefault =
+  Type_Property_Optional_Collections_Bytes_Default.get;
+Scenarios.Type_Property_Optional_CollectionsByte_putDefault =
+  Type_Property_Optional_Collections_Bytes_Default.put;
+Scenarios.Type_Property_Optional_CollectionsByte_getAll =
+  Type_Property_Optional_Collections_Bytes_All.get;
+Scenarios.Type_Property_Optional_CollectionsByte_putAll =
+  Type_Property_Optional_Collections_Bytes_All.put;
+
+const Type_Property_Optional_Collections_Model_Default = createServerTests(
+  `/type/property/optional/collections/model/default`,
+  {},
+);
+const Type_Property_Optional_Collections_Model_All = createServerTests(
+  `/type/property/optional/collections/model/all`,
+  { property: [{ property: "hello" }, { property: "world" }] },
+);
+Scenarios.Type_Property_Optional_CollectionsModel_getDefault =
+  Type_Property_Optional_Collections_Model_Default.get;
+Scenarios.Type_Property_Optional_CollectionsModel_putDefault =
+  Type_Property_Optional_Collections_Model_Default.put;
+Scenarios.Type_Property_Optional_CollectionsModel_getAll =
+  Type_Property_Optional_Collections_Model_All.get;
+Scenarios.Type_Property_Optional_CollectionsModel_putAll =
+  Type_Property_Optional_Collections_Model_All.put;
+
+const Type_Property_Optional_String_Literal_Default = createServerTests(
+  `/type/property/optional/string/literal/default`,
+  {},
+);
+const Type_Property_Optional_String_Literal_All = createServerTests(
+  `/type/property/optional/string/literal/all`,
+  {
+    property: "hello",
+  },
+);
+Scenarios.Type_Property_Optional_StringLiteral_getDefault =
+  Type_Property_Optional_String_Literal_Default.get;
+Scenarios.Type_Property_Optional_StringLiteral_putDefault =
+  Type_Property_Optional_String_Literal_Default.put;
+Scenarios.Type_Property_Optional_StringLiteral_getAll =
+  Type_Property_Optional_String_Literal_All.get;
+Scenarios.Type_Property_Optional_StringLiteral_putAll =
+  Type_Property_Optional_String_Literal_All.put;
+
+const Type_Property_Optional_Int_Literal_Default = createServerTests(
+  `/type/property/optional/int/literal/default`,
+  {},
+);
+const Type_Property_Optional_Int_Literal_All = createServerTests(
+  `/type/property/optional/int/literal/all`,
+  {
+    property: 1,
+  },
+);
+Scenarios.Type_Property_Optional_IntLiteral_getDefault =
+  Type_Property_Optional_Int_Literal_Default.get;
+Scenarios.Type_Property_Optional_IntLiteral_putDefault =
+  Type_Property_Optional_Int_Literal_Default.put;
+Scenarios.Type_Property_Optional_IntLiteral_getAll = Type_Property_Optional_Int_Literal_All.get;
+Scenarios.Type_Property_Optional_IntLiteral_putAll = Type_Property_Optional_Int_Literal_All.put;
+
+const Type_Property_Optional_Float_Literal_Default = createServerTests(
+  `/type/property/optional/float/literal/default`,
+  {},
+);
+const Type_Property_Optional_Float_Literal_All = createServerTests(
+  `/type/property/optional/float/literal/all`,
+  {
+    property: 1.25,
+  },
+);
+Scenarios.Type_Property_Optional_FloatLiteral_getDefault =
+  Type_Property_Optional_Float_Literal_Default.get;
+Scenarios.Type_Property_Optional_FloatLiteral_putDefault =
+  Type_Property_Optional_Float_Literal_Default.put;
+Scenarios.Type_Property_Optional_FloatLiteral_getAll = Type_Property_Optional_Float_Literal_All.get;
+Scenarios.Type_Property_Optional_FloatLiteral_putAll = Type_Property_Optional_Float_Literal_All.put;
+
+const Type_Property_Optional_Boolean_Literal_Default = createServerTests(
+  `/type/property/optional/boolean/literal/default`,
+  {},
+);
+const Type_Property_Optional_Boolean_Literal_All = createServerTests(
+  `/type/property/optional/boolean/literal/all`,
+  { property: true },
+);
+Scenarios.Type_Property_Optional_BooleanLiteral_getDefault =
+  Type_Property_Optional_Boolean_Literal_Default.get;
+Scenarios.Type_Property_Optional_BooleanLiteral_putDefault =
+  Type_Property_Optional_Boolean_Literal_Default.put;
+Scenarios.Type_Property_Optional_BooleanLiteral_getAll =
+  Type_Property_Optional_Boolean_Literal_All.get;
+Scenarios.Type_Property_Optional_BooleanLiteral_putAll =
+  Type_Property_Optional_Boolean_Literal_All.put;
+
+const Type_Property_Optional_Union_String_Literal_Default = createServerTests(
+  `/type/property/optional/union/string/literal/default`,
+  {},
+);
+const Type_Property_Optional_Union_String_Literal_All = createServerTests(
+  `/type/property/optional/union/string/literal/all`,
+  { property: "world" },
+);
+Scenarios.Type_Property_Optional_UnionStringLiteral_getDefault =
+  Type_Property_Optional_Union_String_Literal_Default.get;
+Scenarios.Type_Property_Optional_UnionStringLiteral_putDefault =
+  Type_Property_Optional_Union_String_Literal_Default.put;
+Scenarios.Type_Property_Optional_UnionStringLiteral_getAll =
+  Type_Property_Optional_Union_String_Literal_All.get;
+Scenarios.Type_Property_Optional_UnionStringLiteral_putAll =
+  Type_Property_Optional_Union_String_Literal_All.put;
+
+const Type_Property_Optional_Union_Int_Literal_Default = createServerTests(
+  `/type/property/optional/union/int/literal/default`,
+  {},
+);
+const Type_Property_Optional_Union_Int_Literal_All = createServerTests(
+  `/type/property/optional/union/int/literal/all`,
+  { property: 2 },
+);
+Scenarios.Type_Property_Optional_UnionIntLiteral_getDefault =
+  Type_Property_Optional_Union_Int_Literal_Default.get;
+Scenarios.Type_Property_Optional_UnionIntLiteral_putDefault =
+  Type_Property_Optional_Union_Int_Literal_Default.put;
+Scenarios.Type_Property_Optional_UnionIntLiteral_getAll =
+  Type_Property_Optional_Union_Int_Literal_All.get;
+Scenarios.Type_Property_Optional_UnionIntLiteral_putAll =
+  Type_Property_Optional_Union_Int_Literal_All.put;
+
+const Type_Property_Optional_Union_Float_Literal_Default = createServerTests(
+  `/type/property/optional/union/float/literal/default`,
+  {},
+);
+const Type_Property_Optional_Union_Float_Literal_All = createServerTests(
+  `/type/property/optional/union/float/literal/all`,
+  { property: 2.375 },
+);
+Scenarios.Type_Property_Optional_UnionFloatLiteral_getDefault =
+  Type_Property_Optional_Union_Float_Literal_Default.get;
+Scenarios.Type_Property_Optional_UnionFloatLiteral_putDefault =
+  Type_Property_Optional_Union_Float_Literal_Default.put;
+Scenarios.Type_Property_Optional_UnionFloatLiteral_getAll =
+  Type_Property_Optional_Union_Float_Literal_All.get;
+Scenarios.Type_Property_Optional_UnionFloatLiteral_putAll =
+  Type_Property_Optional_Union_Float_Literal_All.put;
+
+const Type_Property_Optional_Required_And_Optional_RequiredOnly = createServerTests(
+  `/type/property/optional/requiredAndOptional/requiredOnly`,
+  { requiredProperty: 42 },
+);
+Scenarios.Type_Property_Optional_RequiredAndOptional_getRequiredOnly =
+  Type_Property_Optional_Required_And_Optional_RequiredOnly.get;
+Scenarios.Type_Property_Optional_RequiredAndOptional_putRequiredOnly =
+  Type_Property_Optional_Required_And_Optional_RequiredOnly.put;
+
+const Type_Property_Optional_Required_And_Optional_All = createServerTests(
+  `/type/property/optional/requiredAndOptional/all`,
+  {
+    optionalProperty: "hello",
+    requiredProperty: 42,
+  },
+);
+Scenarios.Type_Property_Optional_RequiredAndOptional_getAll =
+  Type_Property_Optional_Required_And_Optional_All.get;
+Scenarios.Type_Property_Optional_RequiredAndOptional_putAll =
+  Type_Property_Optional_Required_And_Optional_All.put;

package/specs/type/property/value-types/main.tsp

@@ -0,0 +1,244 @@
+import "@typespec/http";
+import "@typespec/spector";
+
+using Http;
+using Spector;
+
+@doc("Illustrates various property types for models")
+@scenarioService("/type/property/value-types")
+namespace Type.Property.ValueTypes;
+
+// TEMPLATES
+@doc("Template type for testing models with specific properties. Pass in the type of the property you are looking for")
+model ModelTemplate<TProperty> {
+  @doc("Property")
+  property: TProperty;
+}
+
+@doc("Template to have models operations")
+interface ModelOperations<TModel, TDoc extends valueof string> {
+  #suppress "@azure-tools/typespec-azure-core/use-standard-operations" "For testing"
+  @scenario
+  @scenarioDoc("""
+    Expected response body:
+    ```json
+    {"property": ${TDoc}}
+    ```
+    """)
+  @get
+  @doc("Get call")
+  get(): TModel;
+
+  #suppress "@azure-tools/typespec-azure-core/use-standard-operations" "For testing"
+  @scenario
+  @scenarioDoc("""
+    Expected input body:
+    ```json
+    {"property": ${TDoc}}
+    ```
+    """)
+  @put
+  @doc("Put operation")
+  put(@body @doc("body") body: TModel): void;
+}
+
+// Test a model with a boolean property
+@doc("Model with a boolean property")
+model BooleanProperty is ModelTemplate<boolean>;
+@route("/boolean")
+interface Boolean extends ModelOperations<BooleanProperty, "true"> {}
+
+// Test a model with a string property
+@doc("Model with a string property")
+model StringProperty is ModelTemplate<string>;
+@route("/string")
+interface String extends ModelOperations<StringProperty, "\"hello\""> {}
+
+// Test a model with a bytes property
+@doc("Model with a bytes property")
+model BytesProperty is ModelTemplate<bytes>;
+@route("/bytes")
+interface Bytes extends ModelOperations<BytesProperty, "aGVsbG8sIHdvcmxkIQ=="> {}
+
+// Test a model with an int property
+@doc("Model with a int property")
+model IntProperty is ModelTemplate<int32>;
+@route("/int")
+interface Int extends ModelOperations<IntProperty, "42"> {}
+
+// Test a model with a float property
+@doc("Model with a float property")
+model FloatProperty is ModelTemplate<float32>;
+@route("/float")
+interface Float extends ModelOperations<FloatProperty, "43.125"> {}
+
+// Test a model with a decimal property
+@doc("Model with a decimal property")
+model DecimalProperty is ModelTemplate<decimal>;
+@route("/decimal")
+interface Decimal extends ModelOperations<DecimalProperty, "0.33333"> {}
+
+// Test a model with a decimal128 property
+@doc("Model with a decimal128 property")
+model Decimal128Property is ModelTemplate<decimal128>;
+@route("/decimal128")
+interface Decimal128 extends ModelOperations<Decimal128Property, "0.33333"> {}
+
+// Test a model with a datetime property
+@doc("Model with a datetime property")
+model DatetimeProperty is ModelTemplate<utcDateTime>;
+@route("/datetime")
+interface Datetime extends ModelOperations<DatetimeProperty, "2022-08-26T18:38:00Z"> {}
+
+// Test a model with a duration property
+@doc("Model with a duration property")
+model DurationProperty is ModelTemplate<duration>;
+@route("/duration")
+interface Duration extends ModelOperations<DurationProperty, "P123DT22H14M12.011S"> {}
+
+// Test a model with an enum property
+@doc("Enum that will be used as a property for model EnumProperty. Extensible.")
+union InnerEnum {
+  string,
+
+  @doc("First value.")
+  ValueOne: "ValueOne",
+
+  @doc("Second value.")
+  ValueTwo: "ValueTwo",
+}
+
+@doc("Enum that will be used as a property for model EnumProperty. Non-extensible.")
+enum FixedInnerEnum {
+  @doc("First value.")
+  ValueOne,
+
+  @doc("Second value.")
+  ValueTwo,
+}
+
+@doc("Model with enum properties")
+model EnumProperty is ModelTemplate<FixedInnerEnum>;
+@route("/enum")
+interface Enum extends ModelOperations<EnumProperty, "\"ValueOne\""> {}
+
+@doc("Model with extensible enum properties")
+model ExtensibleEnumProperty is ModelTemplate<InnerEnum>;
+@route("/extensible-enum")
+interface ExtensibleEnum extends ModelOperations<ExtensibleEnumProperty, "\"UnknownValue\""> {}
+
+// Test a model with a model property
+@doc("Inner model. Will be a property type for ModelWithModelProperties")
+model InnerModel {
+  @doc("Required string property")
+  property: string;
+}
+@doc("Model with model properties")
+model ModelProperty is ModelTemplate<InnerModel>;
+@route("/model")
+interface Model extends ModelOperations<ModelProperty, "{'property': 'hello'}"> {}
+
+// Test a model with a string collection property
+@doc("Model with collection string properties")
+model CollectionsStringProperty is ModelTemplate<string[]>;
+@route("/collections/string")
+interface CollectionsString
+  extends ModelOperations<CollectionsStringProperty, "['hello', 'world']"> {}
+
+// Test a model with an int collection property
+@doc("Model with collection int properties")
+model CollectionsIntProperty is ModelTemplate<int32[]>;
+@route("/collections/int")
+interface CollectionsInt extends ModelOperations<CollectionsIntProperty, "[1, 2]"> {}
+
+// Test a model with a model collection property
+@doc("Model with collection model properties")
+model CollectionsModelProperty is ModelTemplate<InnerModel[]>;
+@route("/collections/model")
+interface CollectionsModel
+  extends ModelOperations<
+      CollectionsModelProperty,
+      "[{'property': 'hello'}, {'property': 'world'}]"
+    > {}
+
+// Test a model with a string dictionary property
+@doc("Model with dictionary string properties")
+model DictionaryStringProperty is ModelTemplate<Record<string>>;
+@route("/dictionary/string")
+interface DictionaryString
+  extends ModelOperations<DictionaryStringProperty, "{'k1': 'hello', 'k2': 'world'}"> {}
+
+// Test a model with a never property
+@doc("Model with a property never. (This property should not be included).")
+model NeverProperty is ModelTemplate<never>;
+@route("/never")
+interface Never extends ModelOperations<NeverProperty, "<don't include this property>"> {}
+
+// Test a model with unknown and string
+@doc("Model with a property unknown, and the data is a string.")
+model UnknownStringProperty is ModelTemplate<unknown>;
+@route("/unknown/string")
+interface UnknownString extends ModelOperations<UnknownStringProperty, "\"hello\""> {}
+
+// Test a model with unknown and int
+@doc("Model with a property unknown, and the data is a int32.")
+model UnknownIntProperty is ModelTemplate<unknown>;
+@route("/unknown/int")
+interface UnknownInt extends ModelOperations<UnknownIntProperty, "42"> {}
+
+// Test a model with unknown and a dictionnary
+@doc("Model with a property unknown, and the data is a dictionnary.")
+model UnknownDictProperty is ModelTemplate<unknown>;
+@route("/unknown/dict")
+interface UnknownDict extends ModelOperations<UnknownDictProperty, "{'k1': 'hello', 'k2': 42}"> {}
+
+// Test a model with unknown and an array
+@doc("Model with a property unknown, and the data is an array.")
+model UnknownArrayProperty is ModelTemplate<unknown>;
+@route("/unknown/array")
+interface UnknownArray extends ModelOperations<UnknownArrayProperty, "['hello', 'world']"> {}
+
+@doc("Model with a string literal property.")
+model StringLiteralProperty is ModelTemplate<"hello">;
+@route("/string/literal")
+interface StringLiteral extends ModelOperations<StringLiteralProperty, "\"hello\""> {}
+
+@doc("Model with a int literal property.")
+model IntLiteralProperty is ModelTemplate<42>;
+@route("/int/literal")
+interface IntLiteral extends ModelOperations<IntLiteralProperty, "42"> {}
+
+@doc("Model with a float literal property.")
+model FloatLiteralProperty is ModelTemplate<43.125>;
+@route("/float/literal")
+interface FloatLiteral extends ModelOperations<FloatLiteralProperty, "43.125"> {}
+
+@doc("Model with a boolean literal property.")
+model BooleanLiteralProperty is ModelTemplate<true>;
+@route("/boolean/literal")
+interface BooleanLiteral extends ModelOperations<BooleanLiteralProperty, "true"> {}
+
+@doc("Model with a union of string literal as property.")
+model UnionStringLiteralProperty is ModelTemplate<"hello" | "world">;
+@route("/union/string/literal")
+interface UnionStringLiteral extends ModelOperations<UnionStringLiteralProperty, "\"world\""> {}
+
+@doc("Model with a union of int literal as property.")
+model UnionIntLiteralProperty is ModelTemplate<42 | 43>;
+@route("/union/int/literal")
+interface UnionIntLiteral extends ModelOperations<UnionIntLiteralProperty, "42"> {}
+
+@doc("Model with a union of float literal as property.")
+model UnionFloatLiteralProperty is ModelTemplate<43.125 | 46.875>;
+@route("/union/float/literal")
+interface UnionFloatLiteral extends ModelOperations<UnionFloatLiteralProperty, "46.875"> {}
+
+union ExtendedEnum {
+  string,
+  EnumValue2: "value2",
+}
+
+model UnionEnumValueProperty is ModelTemplate<ExtendedEnum.EnumValue2>;
+
+@route("/union-enum-value")
+interface UnionEnumValue extends ModelOperations<UnionEnumValueProperty, "\"value2\""> {}