@azure-tools/typespec-ts 0.11.0 → 0.12.0-alpha.20230501.1

package/test/commands/cadl-ranch-list.ts

@@ -1,12 +1,13 @@
 export interface CadlRanchConfig {
   outputPath: string;
   inputPath: string;
+  debug?: boolean;
 }
 
 export const cadls: CadlRanchConfig[] = [
   {
     outputPath: "arrays/itemTypes",
-    inputPath: "arrays/item-types"
+    inputPath: "type/array"
   },
   {
     outputPath: "authentication/apiKey",
@@ -22,55 +23,55 @@ export const cadls: CadlRanchConfig[] = [
   },
   {
     outputPath: "dictionary",
-    inputPath: "dictionary"
+    inputPath: "type/dictionary"
   },
   {
     outputPath: "enums/extensible",
-    inputPath: "enums/extensible"
+    inputPath: "type/enum/extensible"
   },
   {
     outputPath: "enums/fixed",
-    inputPath: "enums/fixed"
+    inputPath: "type/enum/fixed"
   },
   {
-    outputPath: "hello",
-    inputPath: "hello"
+    outputPath: "lro/lroCore",
+    inputPath: "azure/core/lro/standard"
   },
   {
-    outputPath: "lro/lroBasic",
-    inputPath: "lro/lro-basic"
+    outputPath: "lro/lroRPC",
+    inputPath: "azure/core/lro/rpc"
   },
   {
     outputPath: "models/inheritance",
-    inputPath: "models/inheritance"
+    inputPath: "type/model/inheritance"
   },
   {
     outputPath: "models/propertyOptional",
-    inputPath: "models/property-optional"
+    inputPath: "type/property/optional"
+  },
+  {
+    outputPath: "models/propertyNullable",
+    inputPath: "type/property/nullable"
   },
   {
     outputPath: "models/propertyTypes",
-    inputPath: "models/property-types"
+    inputPath: "type/property/value-types"
   },
   {
     outputPath: "models/visibility",
-    inputPath: "models/visibility"
+    inputPath: "type/model/visibility"
   },
   {
     outputPath: "models/usage",
-    inputPath: "models/usage"
-  },
-  {
-    outputPath: "resiliency/devDriven",
-    inputPath: "resiliency/dev-driven"
+    inputPath: "type/model/usage"
   },
   {
     outputPath: "resiliency/srvDriven1",
-    inputPath: "resiliency/srv-driven-1"
+    inputPath: "resiliency/srv-driven/old.tsp"
   },
   {
     outputPath: "resiliency/srvDriven2",
-    inputPath: "resiliency/srv-driven-2"
+    inputPath: "resiliency/srv-driven/main.tsp"
   },
   {
     outputPath: "specialWords",
@@ -78,6 +79,38 @@ export const cadls: CadlRanchConfig[] = [
   },
   {
     outputPath: "unions",
-    inputPath: "unions"
+    inputPath: "type/union"
+  },
+  {
+    outputPath: "parameters/collection-format",
+    inputPath: "parameters/collection-format"
+  },
+  {
+    outputPath: "parameters/spread",
+    inputPath: "parameters/spread"
+  },
+  {
+    outputPath: "projection",
+    inputPath: "projection/projected-name"
+  },
+  {
+    outputPath: "internal",
+    inputPath: "azure/client-generator-core/internal"
+  },
+  {
+    outputPath: "server/path/single",
+    inputPath: "server/path/single"
+  },
+  {
+    outputPath: "server/path/multiple",
+    inputPath: "server/path/multiple"
+  },
+  {
+    outputPath: "azure/core",
+    inputPath: "azure/core/basic"
+  },
+  {
+    outputPath: "azure/core-traits",
+    inputPath: "azure/core/traits"
   }
 ];

package/test/commands/gen-cadl-ranch.ts

@@ -4,15 +4,19 @@ import pkg from "chalk";
 const { bold } = pkg;
 const logError = (str: string) => console.error(bold.red(str));
 
-async function generateCadls() {
+async function generateCadls(isDebugging = false) {
   const list = cadls;
   for (const cadl of list) {
+    if (isDebugging === true && cadl.debug !== true) {
+      continue;
+    }
     await runTypespec(cadl);
   }
 }
 
 async function main() {
-  await generateCadls();
+  const isDebugging = process.argv.indexOf("--debug") !== -1;
+  await generateCadls(isDebugging);
 }
 
 main().catch((error) => {

package/test/commands/run.ts

@@ -14,25 +14,15 @@ export async function runTypespec(config: CadlRanchConfig) {
     `${__dirname}`,
     "..",
     "..",
-    `./node_modules/@azure-tools/cadl-ranch-specs/http/${sourceTypespec}`
+    `./temp/http/${sourceTypespec}`
   );
-  // const emitterPath = joinPath(
-  //   `${__dirname}`,
-  //   "..",
-  //   "..",
-  //   "./dist/src/index.js"
-  // );
   const outputPath = joinPath(
     `${__dirname}`,
     "..",
     `./integration/generated/${targetFolder}`
   );
-  const typespecCommand = `cd ${outputPath} && tsp`;
-  const commandArguments: string[] = [
-    "compile",
-    `${typespecPath}`,
-    `--output-path=.`
-  ];
+  const typespecCommand = `cd ${outputPath} && npx tsp`;
+  const commandArguments: string[] = ["compile", `${typespecPath}`];
   const command = `${typespecCommand} ${commandArguments.join(" ")}`;
   console.log(command);
   const result = execSync(command);

package/test/integration/arrayItemTypes.spec.ts

@@ -46,6 +46,10 @@ const testedTypes: TypeDetail[] = [
   {
     type: "model",
     defaultValue: [{ property: "hello" }, { property: "world" }]
+  },
+  {
+    type: "nullable-float",
+    defaultValue: [1.2, null, 3.0]
   }
 ];
 describe("Array Item-Types Client", () => {
@@ -61,10 +65,9 @@ describe("Array Item-Types Client", () => {
     it(`should get a ${params.type} value`, async () => {
       try {
         const result = await client
-          .path(`/arrays/item-types/${params.type}` as any)
+          .path(`/type/array/${params.type}` as any)
           .get();
         assert.strictEqual(result.status, "200");
-        console.log("debug", result.body, params.defaultValue);
         assert.deepEqual(result.body, params.defaultValue);
       } catch (err) {
         assert.fail(err as string);
@@ -80,7 +83,7 @@ describe("Array Item-Types Client", () => {
           property = params.defaultValue;
         }
         const result = await client
-          .path(`/arrays/item-types/${params.type}` as any)
+          .path(`/type/array/${params.type}` as any)
           .put({
             body: property
           });

package/test/integration/azurecore.spec.ts

@@ -0,0 +1,130 @@
+import { assert } from "chai";
+import AzureCoreClientFactory, {
+  AzureCoreClient, buildMultiCollection
+} from "./generated/azure/core/src/index.js";
+import AzureCoreTraitsClientFactory, {
+  AzureCoreTraitsClient
+} from "./generated/azure/core-traits/src/index.js";
+describe("Azure Core Rest Client", () => {
+  let client: AzureCoreClient;
+
+  beforeEach(() => {
+    client = AzureCoreClientFactory({
+      allowInsecureConnection: true,
+      retryOptions: {
+        maxRetries: 0
+      }
+    });
+  });
+
+  it("should put user", async () => {
+    try {
+      const result = await client.path("/azure/core/basic/users/{id}", 1).put({
+        body: {
+          name: "Madge"
+        },
+        contentType: "application/json"
+      });
+      assert.strictEqual(result.status, "200");
+    } catch (err) {
+      assert.fail(err as string);
+    }
+  });
+  it("should patch user", async () => {
+    try {
+      const result = await client.path("/azure/core/basic/users/{id}", 1).patch({
+        contentType: "application/merge-patch+json",
+        body: {
+          name: "Madge"
+        }
+      });
+      assert.strictEqual(result.status, "200");
+    } catch (err) {
+      assert.fail(err as string);
+    }
+  });
+
+  it("should get user", async () => {
+    try {
+      const result = await client.path("/azure/core/basic/users/{id}", 1).get();
+      assert.strictEqual(result.status, "200");
+    } catch (err) {
+      assert.fail(err as string);
+    }
+  });
+
+  it("should delete user", async () => {
+    try {
+      const result = await client.path("/azure/core/basic/users/{id}", 1).delete();
+      assert.strictEqual(result.status, "204");
+    } catch (err) {
+      assert.fail(err as string);
+    }
+  });
+
+  it("should list users", async () => {
+    try {
+      const result = await client.path("/azure/core/basic/users").get({
+        queryParameters: {
+          top: 5,
+          skip: 10,
+          orderby: "id",
+          filter: "id lt 10",
+          select: buildMultiCollection(["id", "orders", "etag"], "select"),
+          expand: "orders"
+        },
+        skipUrlEncoding: true
+      });
+      assert.strictEqual(result.status, "200");
+    } catch (err) {
+      assert.fail(err as string);
+    }
+  });
+
+  it("should list with pages", async () => {
+    try {
+      const result = await client.path("/azure/core/basic/page").get();
+      assert.strictEqual(result.status, "200");
+    } catch (err) {
+      assert.fail(err as string);
+    }
+  });
+});
+
+describe("Azure Core Traits Rest Client", () => {
+  let client: AzureCoreTraitsClient;
+
+  beforeEach(() => {
+    client = AzureCoreTraitsClientFactory({
+      allowInsecureConnection: true,
+      retryOptions: {
+        maxRetries: 0
+      }
+    });
+  });
+
+  it("should get user traits", async () => {
+    try {
+      const result = await client.path("/azure/core/traits/user/{id}", 1).get({
+        headers: {
+          foo: "123",
+          "If-Match": "valid",
+          "If-None-Match": "invalid",
+          "If-Modified-Since": "Thu, 26 Aug 2021 14:38:00 GMT",
+          "If-Unmodified-Since": "Fri, 26 Aug 2022 14:38:00 GMT"
+        }
+      })
+      assert.strictEqual(result.status, "200");
+    } catch (err) {
+      assert.fail(err as string);
+    }
+  });
+  // it("should delete user traits", async () => {
+  //   try {
+  //     const result = await client.path("/azure/traits/api/{apiVersion}/user/{id}", "2022-12-01-preview", 1).delete();
+  //     assert.strictEqual(result.status, "204");
+  //   } catch (err) {
+  //     assert.fail(err as string);
+  //   }
+  // });
+});

package/test/integration/collectionFormat.spec.ts

@@ -0,0 +1,118 @@
+import { assert } from "chai";
+import CollectionFormatClientFactory, {
+  buildMultiCollection,
+  buildPipeCollection,
+  buildSsvCollection,
+  buildTsvCollection,
+  CollectionFormatClient
+} from "./generated/parameters/collection-format/src/index.js";
+describe("Collection Format Rest Client", () => {
+  let client: CollectionFormatClient;
+  const colors = ["blue", "red", "green"];
+
+  beforeEach(() => {
+    client = CollectionFormatClientFactory({
+      allowInsecureConnection: true,
+      retryOptions: {
+        maxRetries: 0
+      }
+    });
+  });
+
+  it("should serialize multi format query array parameter", async () => {
+    try {
+      const result = await client.path("/parameters/collection-format/query/multi").get({
+        queryParameters: {
+          colors: buildMultiCollection(colors, "colors")
+        },
+        skipUrlEncoding: true
+      });
+      assert.strictEqual(result.status, "204");
+    } catch (err) {
+      assert.fail(err as string);
+    }
+  });
+
+  it("should serialize csv format query array parameter", async () => {
+    try {
+      const result = await client.path("/parameters/collection-format/query/csv").get({
+        queryParameters: {
+          colors: colors
+        },
+        skipUrlEncoding: true
+      });
+      assert.strictEqual(result.status, "204");
+    } catch (err) {
+      assert.fail(err as string);
+    }
+  });
+
+  it("should serialize ssv format query array parameter", async () => {
+    try {
+      const result = await client.path("/parameters/collection-format/query/ssv").get({
+        queryParameters: {
+          colors: buildSsvCollection(colors)
+        }
+      });
+      assert.strictEqual(result.status, "204");
+    } catch (err) {
+      assert.fail(err as string);
+    }
+  });
+
+  it("should serialize tsv format query array parameter", async () => {
+    try {
+      const result = await client.path("/parameters/collection-format/query/tsv").get({
+        queryParameters: {
+          colors: buildTsvCollection(colors)
+        }
+      });
+      assert.strictEqual(result.status, "204");
+    } catch (err) {
+      assert.fail(err as string);
+    }
+  });
+
+
+  it("should serialize pipes format query array parameter", async () => {
+    try {
+      const result = await client.path("/parameters/collection-format/query/pipes").get({
+        queryParameters: {
+          colors: buildPipeCollection(colors)
+        },
+        skipUrlEncoding: true
+      });
+      assert.strictEqual(result.status, "204");
+    } catch (err) {
+      assert.fail(err as string);
+    }
+  });
+
+  it("should serialize csv format header array parameter", async () => {
+    try {
+      const result = await client.path("/parameters/collection-format/header/csv").get({
+        headers: {
+          colors: colors as any
+        },
+        skipUrlEncoding: true
+      });
+      assert.strictEqual(result.status, "204");
+    } catch (err) {
+      assert.fail(err as string);
+    }
+  });
+
+  //   it.skip("should serialize default format query array parameter", async () => {
+  //     try {
+  //       const result = await client.path("/collectionFormat/default").get({
+  //         queryParameters: {
+  //           colors: buildMultiCollection(colors, 'colors')
+  //         },
+  //         skipUrlEncoding: true
+  //       });
+  //       assert.strictEqual(result.status, "200");
+  //     } catch (err) {
+  //       assert.fail(err as string);
+  //     }
+  //   });
+});

package/test/integration/dictionary.spec.ts

@@ -56,6 +56,10 @@ const testedTypes: TypeDetail[] = [
         children: { "k2.1": { property: "inner world" } }
       }
     }
+  },
+  {
+    type: "nullable-float",
+    defaultValue: { k1: 1.2, k2: 0.5, k3: null }
   }
 ];
 describe("Dictionary Client", () => {
@@ -71,7 +75,7 @@ describe("Dictionary Client", () => {
     it(`should get a ${params.type} value`, async () => {
       try {
         const result = await client
-          .path(`/dictionary/${params.type}` as any)
+          .path(`/type/dictionary/${params.type}` as any)
           .get();
         assert.strictEqual(result.status, "200");
         assert.deepEqual(result.body, params.defaultValue);
@@ -89,7 +93,7 @@ describe("Dictionary Client", () => {
           property = params.defaultValue;
         }
         const result = await client
-          .path(`/dictionary/${params.type}` as any)
+          .path(`/type/dictionary/${params.type}` as any)
           .put({
             body: property
           });

package/test/integration/extensibleEnums.spec.ts

@@ -1,18 +1,18 @@
-import EnumsExtensibleClientFactory, {
-  EnumsExtensibleClient
+import TypeEnumExtensibleClientFactory, {
+  TypeEnumExtensibleClient
 } from "./generated/enums/extensible/src/index.js";
 import { assert } from "chai";
 describe("ExtensibleEnums Rest Client", () => {
-  let client: EnumsExtensibleClient;
+  let client: TypeEnumExtensibleClient;
 
   beforeEach(() => {
-    client = EnumsExtensibleClientFactory({ allowInsecureConnection: true });
+    client = TypeEnumExtensibleClientFactory({ allowInsecureConnection: true });
   });
 
   it("should get known value", async () => {
     try {
       const result = await client
-        .path("/enums/extensible/string/known-value")
+        .path("/type/enum/extensible/string/known-value")
         .get();
       assert.strictEqual(result.status, "200");
       assert.strictEqual(result.body, "Monday");
@@ -24,7 +24,7 @@ describe("ExtensibleEnums Rest Client", () => {
   it("should put known value", async () => {
     try {
       const result = await client
-        .path("/enums/extensible/string/known-value")
+        .path("/type/enum/extensible/string/known-value")
         .put({
           body: JSON.stringify("Monday")
         });
@@ -37,7 +37,7 @@ describe("ExtensibleEnums Rest Client", () => {
   it("should get unknown value", async () => {
     try {
       const result = await client
-        .path("/enums/extensible/string/unknown-value")
+        .path("/type/enum/extensible/string/unknown-value")
         .get();
       assert.strictEqual(result.status, "200");
       assert.strictEqual(result.body, "Weekend");
@@ -49,7 +49,7 @@ describe("ExtensibleEnums Rest Client", () => {
   it("should put unknown value", async () => {
     try {
       const result = await client
-        .path("/enums/extensible/string/unknown-value")
+        .path("/type/enum/extensible/string/unknown-value")
         .put({
           body: JSON.stringify("Weekend")
         });

package/test/integration/fixedEnums.spec.ts

@@ -1,12 +1,12 @@
 import { assert } from "chai";
-import EnumsFixedClientFactory, {
-  EnumsFixedClient
+import TypeEnumFixedClientFactory, {
+  TypeEnumFixedClient
 } from "./generated/enums/fixed/src/index.js";
 describe("FixedEnums Rest Client", () => {
-  let client: EnumsFixedClient;
+  let client: TypeEnumFixedClient;
 
   beforeEach(() => {
-    client = EnumsFixedClientFactory({
+    client = TypeEnumFixedClientFactory({
       allowInsecureConnection: true,
       retryOptions: {
         maxRetries: 0
@@ -16,7 +16,7 @@ describe("FixedEnums Rest Client", () => {
 
   it("should get known value", async () => {
     try {
-      const result = await client.path("/enums/fixed/string/known-value").get();
+      const result = await client.path("/type/enum/fixed/string/known-value").get();
       assert.strictEqual(result.status, "200");
       assert.strictEqual(result.body, "Monday");
     } catch (err) {
@@ -26,7 +26,7 @@ describe("FixedEnums Rest Client", () => {
 
   it("should put known value", async () => {
     try {
-      const result = await client.path("/enums/fixed/string/known-value").put({
+      const result = await client.path("/type/enum/fixed/string/known-value").put({
         body: "Monday",
         contentType: "application/json"
       });
@@ -39,7 +39,7 @@ describe("FixedEnums Rest Client", () => {
   it("should put unknown value and receives 500", async () => {
     try {
       const result = await client
-        .path("/enums/fixed/string/unknown-value")
+        .path("/type/enum/fixed/string/unknown-value")
         .put({
           body: "Weekend" as any,
           contentType: "application/json"

package/test/integration/generated/arrays/itemTypes/src/clientDefinitions.ts

@@ -20,6 +20,8 @@ import {
   UnknownValuePutParameters,
   ModelValueGetParameters,
   ModelValuePutParameters,
+  NullableFloatValueGetParameters,
+  NullableFloatValuePutParameters,
 } from "./parameters";
 import {
   Int32ValueGet200Response,
@@ -40,6 +42,8 @@ import {
   UnknownValuePut204Response,
   ModelValueGet200Response,
   ModelValuePut204Response,
+  NullableFloatValueGet200Response,
+  NullableFloatValuePut204Response,
 } from "./responses";
 import { Client, StreamableMethod } from "@azure-rest/core-client";
 
@@ -124,25 +128,36 @@ export interface ModelValueGet {
   ): StreamableMethod<ModelValuePut204Response>;
 }
 
+export interface NullableFloatValueGet {
+  get(
+    options?: NullableFloatValueGetParameters
+  ): StreamableMethod<NullableFloatValueGet200Response>;
+  put(
+    options: NullableFloatValuePutParameters
+  ): StreamableMethod<NullableFloatValuePut204Response>;
+}
+
 export interface Routes {
-  /** Resource for '/arrays/item-types/int32' has methods for the following verbs: get, put */
-  (path: "/arrays/item-types/int32"): Int32ValueGet;
-  /** Resource for '/arrays/item-types/int64' has methods for the following verbs: get, put */
-  (path: "/arrays/item-types/int64"): Int64ValueGet;
-  /** Resource for '/arrays/item-types/boolean' has methods for the following verbs: get, put */
-  (path: "/arrays/item-types/boolean"): BooleanValueGet;
-  /** Resource for '/arrays/item-types/string' has methods for the following verbs: get, put */
-  (path: "/arrays/item-types/string"): StringValueGet;
-  /** Resource for '/arrays/item-types/float32' has methods for the following verbs: get, put */
-  (path: "/arrays/item-types/float32"): Float32ValueGet;
-  /** Resource for '/arrays/item-types/datetime' has methods for the following verbs: get, put */
-  (path: "/arrays/item-types/datetime"): DatetimeValueGet;
-  /** Resource for '/arrays/item-types/duration' has methods for the following verbs: get, put */
-  (path: "/arrays/item-types/duration"): DurationValueGet;
-  /** Resource for '/arrays/item-types/unknown' has methods for the following verbs: get, put */
-  (path: "/arrays/item-types/unknown"): UnknownValueGet;
-  /** Resource for '/arrays/item-types/model' has methods for the following verbs: get, put */
-  (path: "/arrays/item-types/model"): ModelValueGet;
+  /** Resource for '/type/array/int32' has methods for the following verbs: get, put */
+  (path: "/type/array/int32"): Int32ValueGet;
+  /** Resource for '/type/array/int64' has methods for the following verbs: get, put */
+  (path: "/type/array/int64"): Int64ValueGet;
+  /** Resource for '/type/array/boolean' has methods for the following verbs: get, put */
+  (path: "/type/array/boolean"): BooleanValueGet;
+  /** Resource for '/type/array/string' has methods for the following verbs: get, put */
+  (path: "/type/array/string"): StringValueGet;
+  /** Resource for '/type/array/float32' has methods for the following verbs: get, put */
+  (path: "/type/array/float32"): Float32ValueGet;
+  /** Resource for '/type/array/datetime' has methods for the following verbs: get, put */
+  (path: "/type/array/datetime"): DatetimeValueGet;
+  /** Resource for '/type/array/duration' has methods for the following verbs: get, put */
+  (path: "/type/array/duration"): DurationValueGet;
+  /** Resource for '/type/array/unknown' has methods for the following verbs: get, put */
+  (path: "/type/array/unknown"): UnknownValueGet;
+  /** Resource for '/type/array/model' has methods for the following verbs: get, put */
+  (path: "/type/array/model"): ModelValueGet;
+  /** Resource for '/type/array/nullable-float' has methods for the following verbs: get, put */
+  (path: "/type/array/nullable-float"): NullableFloatValueGet;
 }
 
 export type ArrayItemTypesClient = Client & {

package/test/integration/generated/arrays/itemTypes/src/parameters.ts

@@ -76,3 +76,11 @@ export interface ModelValuePutBodyParam {
 
 export type ModelValuePutParameters = ModelValuePutBodyParam &
   RequestParameters;
+export type NullableFloatValueGetParameters = RequestParameters;
+
+export interface NullableFloatValuePutBodyParam {
+  body: (number | null)[];
+}
+
+export type NullableFloatValuePutParameters = NullableFloatValuePutBodyParam &
+  RequestParameters;