@azure-tools/rlc-common 1.0.0-beta.1

package/dist-esm/test/template.js

@@ -0,0 +1,189 @@
+export const envContent = `
+import * as dotenv from "dotenv";
+
+dotenv.config();
+`;
+export const envBrowserContent = `
+import * as dotenv from "dotenv";
+
+dotenv.config();
+`;
+export const karmaConfig = `
+// https://github.com/karma-runner/karma-chrome-launcher
+process.env.CHROME_BIN = require("puppeteer").executablePath();
+require("dotenv").config();
+const { relativeRecordingsPath } = require("@azure-tools/test-recorder");
+process.env.RECORDINGS_RELATIVE_PATH = relativeRecordingsPath();
+
+module.exports = function (config) {
+  config.set({
+    // base path that will be used to resolve all patterns (eg. files, exclude)
+    basePath: "./",
+
+    // frameworks to use
+    // available frameworks: https://npmjs.org/browse/keyword/karma-adapter
+    frameworks: ["source-map-support", "mocha"],
+
+    plugins: [
+      "karma-mocha",
+      "karma-mocha-reporter",
+      "karma-chrome-launcher",
+      "karma-edge-launcher",
+      "karma-firefox-launcher",
+      "karma-ie-launcher",
+      "karma-env-preprocessor",
+      "karma-coverage",
+      "karma-sourcemap-loader",
+      "karma-junit-reporter",
+      "karma-source-map-support",
+    ],
+
+    // list of files / patterns to load in the browser
+    files: [
+      "dist-test/index.browser.js",
+      { pattern: "dist-test/index.browser.js.map", type: "html", included: false, served: true },
+    ],
+
+    // list of files / patterns to exclude
+    exclude: [],
+
+    // preprocess matching files before serving them to the browser
+    // available preprocessors: https://npmjs.org/browse/keyword/karma-preprocessor
+    preprocessors: {
+      "**/*.js": ["sourcemap", "env"],
+      // IMPORTANT: COMMENT following line if you want to debug in your browsers!!
+      // Preprocess source file to calculate code coverage, however this will make source file unreadable
+      // "dist-test/index.js": ["coverage"]
+    },
+
+    envPreprocessor: [
+      "TEST_MODE",
+      "ENDPOINT",
+      "AZURE_CLIENT_SECRET",
+      "AZURE_CLIENT_ID",
+      "AZURE_TENANT_ID",
+      "SUBSCRIPTION_ID",
+    ],
+
+    // test results reporter to use
+    // possible values: 'dots', 'progress'
+    // available reporters: https://npmjs.org/browse/keyword/karma-reporter
+    reporters: ["mocha", "coverage", "junit"],
+
+    coverageReporter: {
+      // specify a common output directory
+      dir: "coverage-browser/",
+      reporters: [
+        { type: "json", subdir: ".", file: "coverage.json" },
+        { type: "lcovonly", subdir: ".", file: "lcov.info" },
+        { type: "html", subdir: "html" },
+        { type: "cobertura", subdir: ".", file: "cobertura-coverage.xml" },
+      ],
+    },
+
+    junitReporter: {
+      outputDir: "", // results will be saved as $outputDir/$browserName.xml
+      outputFile: "test-results.browser.xml", // if included, results will be saved as $outputDir/$browserName/$outputFile
+      suite: "", // suite will become the package name attribute in xml testsuite element
+      useBrowserName: false, // add browser name to report and classes names
+      nameFormatter: undefined, // function (browser, result) to customize the name attribute in xml testcase element
+      classNameFormatter: undefined, // function (browser, result) to customize the classname attribute in xml testcase element
+      properties: {}, // key value pair of properties to add to the <properties> section of the report
+    },
+
+    // web server port
+    port: 9876,
+
+    // enable / disable colors in the output (reporters and logs)
+    colors: true,
+
+    // level of logging
+    // possible values: config.LOG_DISABLE || config.LOG_ERROR || config.LOG_WARN || config.LOG_INFO || config.LOG_DEBUG
+    logLevel: config.LOG_INFO,
+
+    // enable / disable watching file and executing tests whenever any file changes
+    autoWatch: false,
+
+    // --no-sandbox allows our tests to run in Linux without having to change the system.
+    // --disable-web-security allows us to authenticate from the browser without having to write tests using interactive auth, which would be far more complex.
+    browsers: ["ChromeHeadlessNoSandbox"],
+    customLaunchers: {
+      ChromeHeadlessNoSandbox: {
+        base: "ChromeHeadless",
+        flags: ["--no-sandbox", "--disable-web-security"],
+      },
+    },
+
+    // Continuous Integration mode
+    // if true, Karma captures browsers, runs the tests and exits
+    singleRun: false,
+
+    // Concurrency level
+    // how many browser should be started simultaneous
+    concurrency: 1,
+
+    browserNoActivityTimeout: 60000000,
+    browserDisconnectTimeout: 10000,
+    browserDisconnectTolerance: 3,
+
+    client: {
+      mocha: {
+        // change Karma's debug.html to the mocha web reporter
+        reporter: "html",
+        timeout: "600000",
+      },
+    },
+  });
+};
+`;
+export const recordedClientContent = `
+import { Context } from "mocha";
+import { Recorder, RecorderStartOptions } from "@azure-tools/test-recorder";
+import "./env";
+
+const envSetupForPlayback: Record<string, string> = {
+  ENDPOINT: "https://endpoint",
+  AZURE_CLIENT_ID: "azure_client_id",
+  AZURE_CLIENT_SECRET: "azure_client_secret",
+  AZURE_TENANT_ID: "88888888-8888-8888-8888-888888888888",
+  SUBSCRIPTION_ID: "azure_subscription_id"
+};
+
+const recorderEnvSetup: RecorderStartOptions = {
+  envSetupForPlayback
+};
+
+/**
+* creates the recorder and reads the environment variables from the \`.env\` file.
+* Should be called first in the test suite to make sure environment variables are
+* read before they are being used.
+*/
+export async function createRecorder(context: Context): Promise<Recorder> {
+  const recorder = new Recorder(context.currentTest);
+  await recorder.start(recorderEnvSetup);
+  return recorder;
+}
+`;
+export const sampleTestContent = `
+import { Recorder } from "@azure-tools/test-recorder";
+import { assert } from "chai";
+import { createRecorder } from "./utils/recordedClient";
+import { Context } from "mocha";
+
+describe("My test", () => {
+  let recorder: Recorder;
+
+  beforeEach(async function(this: Context) {
+    recorder = await createRecorder(this);
+  });
+
+  afterEach(async function() {
+    await recorder.stop();
+  });
+
+  it("sample test", async function() {
+    assert.equal(1, 1);
+  });
+});
+`;
+//# sourceMappingURL=template.js.map

package/dist-esm/test/template.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"template.js","sourceRoot":"","sources":["../../src/test/template.ts"],"names":[],"mappings":"AAAA,MAAM,CAAC,MAAM,UAAU,GAAG;;;;CAIzB,CAAC;AAEF,MAAM,CAAC,MAAM,iBAAiB,GAAG;;;;CAIhC,CAAC;AAEF,MAAM,CAAC,MAAM,WAAW,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA+H1B,CAAC;AAEF,MAAM,CAAC,MAAM,qBAAqB,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;CA2BpC,CAAC;AAEF,MAAM,CAAC,MAAM,iBAAiB,GAAG;;;;;;;;;;;;;;;;;;;;;CAqBhC,CAAC"}

package/package.json

@@ -0,0 +1,40 @@
+{
+  "name": "@azure-tools/rlc-common",
+  "version": "1.0.0-beta.1",
+  "description": "",
+  "type": "module",
+  "main": "dist/index.js",
+  "module": "dist-esm/index.js",
+  "exports": {
+    ".": {
+      "types": "./types/index.d.ts",
+      "require": "./dist/index.js",
+      "import": "./dist-esm/index.js"
+    }
+  },
+  "types": "./types/index.d.ts",
+  "scripts": {
+    "build": "rimraf dist/* dist-esm/* types/* && tsc -p tsconfig.json && tsc -p tsconfig-cjs.json && node publishPackage.js",
+    "build:cjs":"rimraf dist/* dist-esm/* types/* && tsc -p tsconfig-cjs.json && node publishPackage.js",
+    "build:esm":"rimraf dist/* dist-esm/* types/* && tsc -p tsconfig.json && node publishPackage.js",
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "keywords": [],
+  "author": "",
+  "license": "ISC",
+  "dependencies": {
+    "ts-morph": "^15.1.0",
+    "lodash": "^4.17.21",
+    "handlebars": "^4.7.7"
+  },
+  "devDependencies": {
+    "@types/node": "^18.0.0",
+    "prettier": "~2.7.1",
+    "typescript": "^4.6.3",
+    "rimraf": "^3.0.2",
+    "@types/lodash": "^4.14.182",
+    "fs-extra": "^10.0.0",
+    "@types/fs-extra": "^8.1.0",
+    "ts-node": "^10.7.0"
+  }
+}

package/publishPackage.js

@@ -0,0 +1,11 @@
+import { writeFileSync } from "fs";
+import { createRequire } from "module";
+const require = createRequire(import.meta.url);
+const p = require("./package.json");
+
+const cjsPackage = { ...p, type: "commonjs" };
+writeFileSync("./dist/package.json", JSON.stringify(cjsPackage));
+
+
+const esmPackage = { ...p, type: "module" };
+writeFileSync("./dist-esm/package.json", JSON.stringify(esmPackage));

package/rlc-common.build.log

@@ -0,0 +1,2 @@
+Invoking: rimraf dist/* dist-esm/* types/* && tsc -p tsconfig.json && tsc -p tsconfig-cjs.json && node publishPackage.js 
+

package/src/buildClient.ts

@@ -0,0 +1,251 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+import {
+  Project,
+  StatementStructures,
+  StructureKind,
+  VariableDeclarationKind,
+  VariableStatementStructure,
+  WriterFunction
+} from "ts-morph";
+import * as path from "path";
+import { NameType, normalizeName } from "./helpers/nameUtils.js";
+import { isConstantSchema } from "./helpers/schemaHelpers.js";
+import { buildMethodShortcutImplementation } from "./buildMethodShortcuts.js";
+import { RLCModel, Schema, File } from "./interfaces.js";
+
+export function buildClient(model: RLCModel): File | undefined {
+  const name = normalizeName(model.libraryName, NameType.File);
+  const { srcPath } = model;
+  const project = new Project();
+  const filePath = path.join(srcPath, `${name}.ts`);
+  const clientFile = project.createSourceFile(filePath, undefined, {
+    overwrite: true
+  });
+
+  // Get all paths
+  const clientName = model.libraryName;
+  const urlParameters = model?.urlInfo?.urlParameters;
+
+  if (!model.options) {
+    return undefined;
+  }
+  const { multiClient, batch } = model.options;
+  const { addCredentials, credentialScopes, credentialKeyHeaderName } =
+    model.options;
+  const credentialTypes =
+    credentialScopes && credentialScopes.length > 0 ? ["TokenCredential"] : [];
+
+  if (credentialKeyHeaderName) {
+    credentialTypes.push("KeyCredential");
+  }
+
+  const commonClientParams = [
+    ...(urlParameters ?? []),
+    ...(addCredentials === false ||
+    !isSecurityInfoDefined(credentialScopes, credentialKeyHeaderName)
+      ? []
+      : [{ name: "credentials", type: credentialTypes.join(" | ") }])
+  ];
+  const clientInterfaceName = clientName.endsWith("Client")
+    ? `${clientName}`
+    : `${clientName}Client`;
+
+  const functionStatement = {
+    isExported: true,
+    name: `createClient`,
+    parameters: [
+      ...commonClientParams,
+      { name: "options", type: "ClientOptions = {}" }
+    ],
+    docs: [
+      {
+        description:
+          `Initialize a new instance of the class ${clientInterfaceName} class. \n` +
+          commonClientParams
+            .map((param) => {
+              return `@param ${param.name} type: ${param.type} ${param.description ?? ""}`;
+            })
+            .join("\n")
+      }
+    ],
+    returnType: clientInterfaceName,
+    isDefaultExport: false,
+    statements: getClientFactoryBody(model, clientInterfaceName)
+  };
+
+  if (!multiClient || !batch || batch.length === 1) {
+    functionStatement.isDefaultExport = true;
+  }
+  clientFile.addFunction(functionStatement);
+
+  clientFile.addImportDeclarations([
+    {
+      namedImports: ["getClient", "ClientOptions"],
+      moduleSpecifier: "@azure-rest/core-client"
+    }
+  ]);
+
+  if (
+    addCredentials &&
+    isSecurityInfoDefined(credentialScopes, credentialKeyHeaderName)
+  ) {
+    clientFile.addImportDeclarations([
+      {
+        namedImports: credentialTypes,
+        moduleSpecifier: "@azure/core-auth"
+      }
+    ]);
+  }
+  clientFile.addImportDeclarations([
+    {
+      namedImports: [`${clientInterfaceName}`],
+      moduleSpecifier: "./clientDefinitions"
+    }
+  ]);
+  return { path: filePath, content: clientFile.getFullText() };
+}
+
+function isSecurityInfoDefined(
+  credentialScopes?: string[],
+  credentialKeyHeaderName?: string
+) {
+  return (
+    (credentialScopes && credentialScopes.length > 0) || credentialKeyHeaderName
+  );
+}
+
+function getClientFactoryBody(
+  model: RLCModel,
+  clientTypeName: string
+): string | WriterFunction | (string | WriterFunction | StatementStructures)[] {
+  if (!model.options || !model.options.packageDetails || !model.urlInfo) {
+    return "";
+  }
+  const { includeShortcuts, packageDetails } = model.options;
+  let clientPackageName = packageDetails.nameWithoutScope ?? "";
+  const packageVersion = packageDetails.version;
+  const { endpoint, urlParameters } = model.urlInfo;
+  let baseUrl: string;
+  if (urlParameters && endpoint) {
+    let parsedEndpoint = endpoint;
+    urlParameters.forEach((urlParameter) => {
+      parsedEndpoint = parsedEndpoint.replace(
+        `{${urlParameter.name}}`,
+        `\${${urlParameter.name}}`
+      );
+    });
+
+    baseUrl = `options.baseUrl ?? \`${parsedEndpoint}\``;
+  } else {
+    baseUrl = `options.baseUrl ?? "${endpoint}"`;
+  }
+
+  const apiVersion = getApiVersion(model);
+  let apiVersionStatement: string = "";
+  if (apiVersion) {
+    apiVersionStatement = `options.apiVersion = options.apiVersion ?? "${apiVersion}"`;
+  }
+
+  if (!clientPackageName.endsWith("-rest")) {
+    clientPackageName = clientPackageName + "-rest";
+  }
+  const userAgentInfoStatement =
+    "const userAgentInfo = `azsdk-js-" +
+    clientPackageName +
+    "/" +
+    packageVersion +
+    "`;";
+  const userAgentPrefix =
+    "options.userAgentOptions && options.userAgentOptions.userAgentPrefix ? `${options.userAgentOptions.userAgentPrefix} ${userAgentInfo}`: `${userAgentInfo}`;";
+  const userAgentStatement: VariableStatementStructure = {
+    kind: StructureKind.VariableStatement,
+    declarationKind: VariableDeclarationKind.Const,
+    declarations: [{ name: "userAgentPrefix", initializer: userAgentPrefix }]
+  };
+
+  const userAgentOptionsStatement = `options = {
+      ...options,
+      userAgentOptions: {
+        userAgentPrefix
+      }
+    }`;
+
+  const baseUrlStatement: VariableStatementStructure = {
+    kind: StructureKind.VariableStatement,
+    declarationKind: VariableDeclarationKind.Const,
+    declarations: [{ name: "baseUrl", initializer: baseUrl }]
+  };
+
+  const { credentialScopes, credentialKeyHeaderName } = model.options;
+
+  const scopesString =
+    credentialScopes && credentialScopes.length
+      ? credentialScopes.map((cs) => `"${cs}"`).join(", ")
+      : "";
+  const scopes = scopesString ? `scopes: [${scopesString}],` : "";
+
+  const apiKeyHeaderName = credentialKeyHeaderName
+    ? `apiKeyHeaderName: "${credentialKeyHeaderName}",`
+    : "";
+
+  const credentials =
+    scopes || apiKeyHeaderName
+      ? `options = {
+        ...options,
+        credentials: {
+          ${scopes}
+          ${apiKeyHeaderName}
+        },
+      }`
+      : "";
+
+  const getClient = `const client = getClient(
+        baseUrl, ${credentials ? "credentials," : ""} options
+      ) as ${clientTypeName};
+      `;
+
+  let returnStatement = `return client;`;
+
+  if (includeShortcuts) {
+    const shortcutImplementations = buildMethodShortcutImplementation(
+      model.paths
+    );
+    const shortcutBody = Object.keys(shortcutImplementations).map((key) => {
+      // If the operation group has an empty name, it means its operations are client
+      // level operations so we need to spread the definitions. Otherwise they are
+      // within an operation group so we add them as key: value
+      return `${
+        key && key !== "client" ? `"${key}":` : "..."
+      } {${shortcutImplementations[key].join()}}`;
+    });
+    returnStatement = `return { ...client, ${shortcutBody.join()} };`;
+  }
+
+  return [
+    baseUrlStatement,
+    apiVersionStatement,
+    credentials,
+    userAgentInfoStatement,
+    userAgentStatement,
+    userAgentOptionsStatement,
+    getClient,
+    returnStatement
+  ];
+}
+
+function getApiVersion(model: RLCModel): string | undefined {
+  if (!model.apiVersionParam) {
+    return undefined;
+  }
+
+  if (
+    model.apiVersionParam &&
+    isConstantSchema(model.apiVersionParam as Schema)
+  ) {
+    return model.apiVersionParam.default;
+  }
+
+  return undefined;
+}