@azure-tools/typespec-ts 0.11.0

package/src/transform/transfromRLCOptions.ts

@@ -0,0 +1,202 @@
+import {
+  DpgContext,
+  listClients
+} from "@azure-tools/typespec-client-generator-core";
+import {
+  NameType,
+  normalizeName,
+  PackageDetails,
+  RLCOptions,
+  ServiceInfo
+} from "@azure-tools/rlc-common";
+import { getDoc, NoTarget, Program } from "@typespec/compiler";
+import { getAuthentication } from "@typespec/http";
+import { getDefaultService } from "./transform.js";
+import { reportDiagnostic } from "../lib.js";
+
+export function transformRLCOptions(
+  program: Program,
+  emitterOptions: RLCOptions,
+  emitterOutputDir: string,
+  dpgContext: DpgContext
+): RLCOptions {
+  // Extract the options from emitter option
+  const options = extractRLCOptions(program, emitterOptions, emitterOutputDir);
+  const batch = listClients(dpgContext);
+  options.batch = batch;
+  return options;
+}
+
+function extractRLCOptions(
+  program: Program,
+  emitterOptions: RLCOptions,
+  emitterOutputDir: string
+): RLCOptions {
+  const includeShortcuts = getIncludeShortcuts(emitterOptions);
+  const packageDetails = getPackageDetails(program, emitterOptions);
+  const serviceInfo = getServiceInfo(program);
+  const azureSdkForJs = getAzureSdkForJs(emitterOptions);
+  const generateMetadata = getGenerateMetadata(emitterOptions);
+  const generateTest = getGenerateTest(emitterOptions);
+  const credentialInfo = getCredentialInfo(program, emitterOptions);
+  const azureOutputDirectory = getAzureOutputDirectory(emitterOutputDir);
+  return {
+    ...emitterOptions,
+    ...credentialInfo,
+    includeShortcuts,
+    packageDetails,
+    generateMetadata,
+    generateTest,
+    azureSdkForJs,
+    serviceInfo,
+    azureOutputDirectory,
+    sourceFrom: "Cadl"
+  };
+}
+
+function processAuth(program: Program) {
+  const serviceNs = getDefaultService(program)?.type;
+  if (!serviceNs) {
+    return undefined;
+  }
+  const authorization = getAuthentication(program, serviceNs);
+  if (!authorization || !authorization.options) {
+    return undefined;
+  }
+  const securityInfo: RLCOptions = {};
+  for (const option of authorization.options) {
+    for (const auth of option.schemes) {
+      switch (auth.type) {
+        case "http":
+          break;
+        case "apiKey":
+          if (auth.in === "cookie") {
+            return undefined;
+          }
+          securityInfo.addCredentials = true;
+          securityInfo.credentialKeyHeaderName = auth.name;
+          break;
+        case "oauth2": {
+          const flow = auth.flows[0];
+          if (flow === undefined || !flow.scopes) {
+            return undefined;
+          }
+          securityInfo.addCredentials = true;
+          if (!securityInfo.credentialScopes) {
+            securityInfo.credentialScopes = [];
+          }
+          if (flow.scopes.length === 0) {
+            reportDiagnostic(program, {
+              code: "no-credential-scopes",
+              target: NoTarget
+            });
+          }
+          securityInfo.credentialScopes.push(
+            ...flow.scopes.map((item) => {
+              return item.value;
+            })
+          );
+          break;
+        }
+        default:
+          break;
+      }
+    }
+  }
+  return securityInfo;
+}
+
+function getIncludeShortcuts(emitterOptions: RLCOptions) {
+  return Boolean(emitterOptions.includeShortcuts);
+}
+
+function getPackageDetails(
+  program: Program,
+  emitterOptions: RLCOptions
+): PackageDetails {
+  const packageDetails: PackageDetails = {
+    ...emitterOptions.packageDetails,
+    name:
+      emitterOptions.packageDetails?.name ??
+      normalizeName(
+        emitterOptions?.title ?? getDefaultService(program)?.title ?? "",
+        NameType.Class
+      ),
+    version: emitterOptions.packageDetails?.version ?? "1.0.0-beta.1"
+  };
+  if (emitterOptions.packageDetails?.name) {
+    const nameParts = emitterOptions.packageDetails?.name.split("/");
+    if (nameParts.length === 2) {
+      packageDetails.nameWithoutScope = nameParts[1];
+      packageDetails.scopeName = nameParts[0]?.replace("@", "");
+    }
+  }
+  return packageDetails;
+}
+
+function getServiceInfo(program: Program): ServiceInfo {
+  const defaultService = getDefaultService(program);
+  return {
+    title: defaultService?.title,
+    description: defaultService && getDoc(program, defaultService.type)
+  };
+}
+
+function getAzureSdkForJs(emitterOptions: RLCOptions) {
+  return emitterOptions.azureSdkForJs === undefined ||
+    emitterOptions.azureSdkForJs === null
+    ? true
+    : Boolean(emitterOptions.azureSdkForJs);
+}
+
+function getGenerateMetadata(emitterOptions: RLCOptions) {
+  return emitterOptions.generateMetadata === undefined ||
+    emitterOptions.generateMetadata === null
+    ? true
+    : Boolean(emitterOptions.generateMetadata);
+}
+
+function getGenerateTest(emitterOptions: RLCOptions) {
+  return emitterOptions.generateTest === undefined ||
+    emitterOptions.generateTest === null
+    ? true
+    : Boolean(emitterOptions.generateTest);
+}
+
+export function getCredentialInfo(
+  program: Program,
+  emitterOptions: RLCOptions
+) {
+  const securityInfo = processAuth(program);
+  const addCredentials =
+    !securityInfo && emitterOptions.addCredentials === false
+      ? false
+      : securityInfo
+      ? securityInfo.addCredentials
+      : emitterOptions.addCredentials;
+  const credentialScopes =
+    securityInfo && securityInfo.credentialScopes
+      ? securityInfo.credentialScopes
+      : emitterOptions.credentialScopes;
+  const credentialKeyHeaderName =
+    securityInfo && securityInfo.credentialKeyHeaderName
+      ? securityInfo.credentialKeyHeaderName
+      : emitterOptions.credentialKeyHeaderName;
+  return {
+    addCredentials,
+    credentialScopes,
+    credentialKeyHeaderName
+  };
+}
+
+function getAzureOutputDirectory(emitterOutputDir: string): string | undefined {
+  const sdkFolder = emitterOutputDir;
+  const sdkReletivePath = sdkFolder
+    ?.replace(/\/$/, "")
+    .split("/")
+    .slice(-3)
+    .join("/");
+  return sdkReletivePath?.substring(0, 3) === "sdk"
+    ? sdkReletivePath
+    : undefined;
+}

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

@@ -0,0 +1,83 @@
+export interface CadlRanchConfig {
+  outputPath: string;
+  inputPath: string;
+}
+
+export const cadls: CadlRanchConfig[] = [
+  {
+    outputPath: "arrays/itemTypes",
+    inputPath: "arrays/item-types"
+  },
+  {
+    outputPath: "authentication/apiKey",
+    inputPath: "authentication/api-key"
+  },
+  {
+    outputPath: "authentication/oauth2",
+    inputPath: "authentication/oauth2"
+  },
+  {
+    outputPath: "authentication/union",
+    inputPath: "authentication/union"
+  },
+  {
+    outputPath: "dictionary",
+    inputPath: "dictionary"
+  },
+  {
+    outputPath: "enums/extensible",
+    inputPath: "enums/extensible"
+  },
+  {
+    outputPath: "enums/fixed",
+    inputPath: "enums/fixed"
+  },
+  {
+    outputPath: "hello",
+    inputPath: "hello"
+  },
+  {
+    outputPath: "lro/lroBasic",
+    inputPath: "lro/lro-basic"
+  },
+  {
+    outputPath: "models/inheritance",
+    inputPath: "models/inheritance"
+  },
+  {
+    outputPath: "models/propertyOptional",
+    inputPath: "models/property-optional"
+  },
+  {
+    outputPath: "models/propertyTypes",
+    inputPath: "models/property-types"
+  },
+  {
+    outputPath: "models/visibility",
+    inputPath: "models/visibility"
+  },
+  {
+    outputPath: "models/usage",
+    inputPath: "models/usage"
+  },
+  {
+    outputPath: "resiliency/devDriven",
+    inputPath: "resiliency/dev-driven"
+  },
+  {
+    outputPath: "resiliency/srvDriven1",
+    inputPath: "resiliency/srv-driven-1"
+  },
+  {
+    outputPath: "resiliency/srvDriven2",
+    inputPath: "resiliency/srv-driven-2"
+  },
+  {
+    outputPath: "specialWords",
+    inputPath: "special-words"
+  },
+  {
+    outputPath: "unions",
+    inputPath: "unions"
+  }
+];

package/test/commands/check-clean-tree.ts

@@ -0,0 +1,55 @@
+import { spawn, ChildProcess } from "child_process";
+
+const onExit = (childProcess: ChildProcess): Promise<string[]> => {
+  let messages: string[] = [];
+  return new Promise((resolve, reject) => {
+    if (childProcess.stdout) {
+      childProcess.stdout.on("data", (message) => messages.push(message));
+    }
+    childProcess.once("exit", (code: number) => {
+      if (code === 0) {
+        resolve(messages);
+      }
+      reject(new Error(`Exit with code: ${code}`));
+    });
+
+    childProcess.once("error", (error: Error) => {
+      reject(error);
+    });
+  });
+};
+
+async function check_tree() {
+  await onExit(
+    spawn("git", ["add", "-A"], {
+      stdio: [process.stdin, process.stdout, process.stderr]
+    })
+  );
+
+  // If there is any output from this command it means that
+  // there are non committed changes so we need to handle
+  // stout
+  const messages = await onExit(
+    spawn("git", ["diff", "--staged", "--compact-summary"])
+  );
+
+  if (messages.length !== 0) {
+    // Once we have verified that there are non committed changes
+    // run git diff again, this time forwarding the stout to present
+    // a readable hint to the user
+    await onExit(
+      spawn("git", ["diff", "--staged", "--compact-summary"], {
+        stdio: [process.stdin, process.stdout, process.stderr]
+      })
+    );
+
+    throw new Error(
+      "Git tree is dirty, regenerate all test cadl files and make sure that there are no un-intended changes"
+    );
+  }
+}
+
+check_tree().catch((error) => {
+  console.error(error);
+  process.exit(-1);
+});

package/test/commands/childProcessOnExit.ts

@@ -0,0 +1,16 @@
+import { ChildProcess } from "child_process";
+
+export const onExit = (childProcess: ChildProcess) => {
+  return new Promise<void>((resolve, reject) => {
+    childProcess.once("exit", (code: number) => {
+      if (code === 0) {
+        resolve();
+      }
+      reject(new Error(`Exit with code: ${code}`));
+    });
+
+    childProcess.once("error", (error: Error) => {
+      reject(error);
+    });
+  });
+};

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

@@ -0,0 +1,21 @@
+import { cadls } from "./cadl-ranch-list.js";
+import { runTypespec } from "./run.js";
+import pkg from "chalk";
+const { bold } = pkg;
+const logError = (str: string) => console.error(bold.red(str));
+
+async function generateCadls() {
+  const list = cadls;
+  for (const cadl of list) {
+    await runTypespec(cadl);
+  }
+}
+
+async function main() {
+  await generateCadls();
+}
+
+main().catch((error) => {
+  logError(error);
+  process.exit(-1);
+});

package/test/commands/run.ts

@@ -0,0 +1,41 @@
+import { execSync } from "child_process";
+import { dirname, join as joinPath } from "path";
+import { fileURLToPath } from "url";
+import { CadlRanchConfig } from "./cadl-ranch-list.js";
+
+export async function runTypespec(config: CadlRanchConfig) {
+  const targetFolder = config.outputPath,
+    sourceTypespec = config.inputPath;
+  const __filename = fileURLToPath(import.meta.url);
+  const __dirname = dirname(__filename);
+  console.log(`=== Start ${targetFolder} ===`);
+
+  const typespecPath = joinPath(
+    `${__dirname}`,
+    "..",
+    "..",
+    `./node_modules/@azure-tools/cadl-ranch-specs/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 command = `${typespecCommand} ${commandArguments.join(" ")}`;
+  console.log(command);
+  const result = execSync(command);
+  console.log(`=== End ${targetFolder} ===`);
+  return result;
+}

package/test/integration/arrayItemTypes.spec.ts

@@ -0,0 +1,93 @@
+import ArrayItemTypesClientFactory, {
+  ArrayItemTypesClient
+} from "./generated/arrays/itemTypes/src/index.js";
+import { assert } from "chai";
+import { matrix } from "../util/matrix.js";
+
+interface TypeDetail {
+  type: string;
+  defaultValue: any;
+  convertedToFn?: (_: any) => any;
+}
+
+const testedTypes: TypeDetail[] = [
+  {
+    type: "int32",
+    defaultValue: [1, 2]
+  },
+  {
+    type: "int64",
+    defaultValue: [Number.MAX_SAFE_INTEGER, Number.MIN_SAFE_INTEGER]
+  },
+  {
+    type: "boolean",
+    defaultValue: [true, false]
+  },
+  {
+    type: "string",
+    defaultValue: ["hello", ""]
+  },
+  {
+    type: "float32",
+    defaultValue: [42.42]
+  },
+  {
+    type: "datetime",
+    defaultValue: ["2022-08-26T18:38:00Z"]
+  },
+  {
+    type: "duration",
+    defaultValue: ["P123DT22H14M12.011S"]
+  },
+  {
+    type: "unknown",
+    defaultValue: [1, "hello", null]
+  },
+  {
+    type: "model",
+    defaultValue: [{ property: "hello" }, { property: "world" }]
+  }
+];
+describe("Array Item-Types Client", () => {
+  let client: ArrayItemTypesClient;
+
+  beforeEach(() => {
+    client = ArrayItemTypesClientFactory({
+      allowInsecureConnection: true
+    });
+  });
+
+  matrix([testedTypes], async (params: TypeDetail) => {
+    it(`should get a ${params.type} value`, async () => {
+      try {
+        const result = await client
+          .path(`/arrays/item-types/${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);
+      }
+    });
+
+    it(`should put a ${params.type} value`, async () => {
+      try {
+        let property;
+        if (params.convertedToFn) {
+          property = params.convertedToFn(params.defaultValue);
+        } else {
+          property = params.defaultValue;
+        }
+        const result = await client
+          .path(`/arrays/item-types/${params.type}` as any)
+          .put({
+            body: property
+          });
+        assert.strictEqual(result.status, "204");
+      } catch (err) {
+        assert.fail(err as string);
+      }
+    });
+  });
+});

package/test/integration/authApiKey.spec.ts

@@ -0,0 +1,38 @@
+import ApiKeyClientFactory, {
+  AuthApiKeyClient
+} from "./generated/authentication/apiKey/src/index.js";
+import { assert } from "chai";
+describe("AuthApiKeyClient Rest Client", () => {
+  let client: AuthApiKeyClient;
+
+  beforeEach(() => {
+    client = ApiKeyClientFactory(
+      {
+        key: "valid-key"
+      },
+      { allowInsecureConnection: true }
+    );
+  });
+
+  it("should return 204 when the apiKey is valid", async () => {
+    try {
+      const result = await client.path("/authentication/api-key/valid").get();
+      assert.strictEqual(result.status, "204");
+    } catch (err) {
+      console.log(err);
+      assert.fail(err as string);
+    }
+  });
+
+  it("should return 403 when the apiKey is invalid", async () => {
+    try {
+      const result = await client.path("/authentication/api-key/invalid").get();
+      assert.strictEqual(result.status, "403");
+      if (result.status === "403") {
+        assert.strictEqual(result.body.error, "invalid-api-key");
+      }
+    } catch (err) {
+      assert.fail(err as string);
+    }
+  });
+});

package/test/integration/authOauth2.spec.ts

@@ -0,0 +1,65 @@
+import Outh2ClientFactory, {
+  AuthOauth2Client
+} from "./generated/authentication/oauth2/src/index.js";
+import { assert } from "chai";
+import {
+  bearerTokenAuthenticationPolicyName,
+  PipelinePolicy
+} from "@azure/core-rest-pipeline";
+import { customBearerTokenAuthenticationPolicy } from "../util/customBearerTokenTestingPolicy.js";
+
+describe("AuthOauth2Client Rest Client", () => {
+  let client: AuthOauth2Client;
+  let policy: PipelinePolicy;
+  const defaultScope = "https://security.microsoft.com/.default";
+
+  beforeEach(() => {
+    client = Outh2ClientFactory(
+      {
+        getToken: async () => Promise.resolve(null)
+      },
+      { allowInsecureConnection: true }
+    );
+    policy = customBearerTokenAuthenticationPolicy({
+      scopes: defaultScope,
+      credential: {
+        getToken: async () => {
+          return {
+            token: defaultScope,
+            expiresOnTimestamp: Date.now()
+          };
+        }
+      }
+    });
+    client.pipeline.removePolicy({
+      name: bearerTokenAuthenticationPolicyName
+    });
+    client.pipeline.addPolicy(policy);
+  });
+
+  it("should return 204 when the token is valid", async () => {
+    try {
+      const result = await client.path("/authentication/oauth2/valid").get();
+      assert.strictEqual(result.status, "204");
+    } catch (err) {
+      console.log(err);
+      assert.fail(err as string);
+    }
+  });
+
+  it("should return 403 when the token is invalid", async () => {
+    try {
+      client.pipeline.removePolicy({
+        name: bearerTokenAuthenticationPolicyName
+      });
+      const result = await client.path("/authentication/oauth2/invalid").get();
+      assert.strictEqual(result.status, "403");
+      if (result.status === "403") {
+        assert.strictEqual(result.body.error, "invalid-grant");
+      }
+    } catch (err) {
+      console.log(err);
+      assert.fail(err as string);
+    }
+  });
+});

package/test/integration/authUnion.spec.ts

@@ -0,0 +1,72 @@
+import { assert } from "chai";
+import {
+  bearerTokenAuthenticationPolicyName,
+  PipelinePolicy
+} from "@azure/core-rest-pipeline";
+import { customBearerTokenAuthenticationPolicy } from "../util/customBearerTokenTestingPolicy.js";
+import AuthUnionClientFactory, {
+  AuthUnionClient
+} from "./generated/authentication/union/src/index.js";
+
+describe("AuthUnionClient Rest Client", () => {
+  let client: AuthUnionClient;
+  let policy: PipelinePolicy;
+  const defaultScope = "https://security.microsoft.com/.default";
+
+  function prepareToken() {
+    client = AuthUnionClientFactory(
+      {
+        getToken: async () => Promise.resolve(null)
+      },
+      { allowInsecureConnection: true }
+    );
+    policy = customBearerTokenAuthenticationPolicy({
+      scopes: defaultScope,
+      credential: {
+        getToken: async () => {
+          return {
+            token: defaultScope,
+            expiresOnTimestamp: Date.now()
+          };
+        }
+      }
+    });
+    client.pipeline.removePolicy({
+      name: bearerTokenAuthenticationPolicyName
+    });
+    client.pipeline.addPolicy(policy);
+  }
+
+  function prepareKey() {
+    client = AuthUnionClientFactory(
+      {
+        key: "valid-key"
+      },
+      { allowInsecureConnection: true }
+    );
+  }
+
+  it("should return 204 when the token is valid", async () => {
+    prepareToken();
+    try {
+      const result = await client
+        .path("/authentication/union/validtoken")
+        .get();
+      assert.strictEqual(result.status, "204");
+    } catch (err) {
+      console.log(err);
+      assert.fail(err as string);
+    }
+  });
+
+  it("should return 204 when the key is valid", async () => {
+    prepareKey();
+    try {
+      const result = await client.path("/authentication/union/validkey").get();
+      assert.strictEqual(result.status, "204");
+    } catch (err) {
+      console.log(err);
+      assert.fail(err as string);
+    }
+  });
+});