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

package/src/modular/buildOperations.ts

@@ -0,0 +1,95 @@
+import { Project, SourceFile } from "ts-morph";
+import { buildType } from "./helpers/typeHelpers.js";
+import {
+  getOperationFunction,
+  getOperationOptionsName
+} from "./helpers/operationHelpers.js";
+import { Client, Operation } from "./modularCodeModel.js";
+
+/**
+ * This function creates a file under /api for each operation group.
+ * If there is no operation group in the TypeSpec program, we create a single
+ * file called operations.ts where all operations are generated.
+ */
+export function buildOperationFiles(
+  client: Client,
+  project: Project,
+  srcPath: string = "src"
+) {
+  for (const operationGroup of client.operationGroups) {
+    const fileName = operationGroup.className
+      ? `${operationGroup.className}`
+      : // When the program has no operation groups defined all operations are put
+        // into a nameless operation group. We'll call this operations.
+        "operations";
+
+    const operationGroupFile = project.createSourceFile(
+      `${srcPath}/src/api/${fileName}.ts`
+    );
+
+    operationGroup.operations.forEach((o) => {
+      buildOperationOptions(o, operationGroupFile);
+      const operationDeclaration = getOperationFunction(o);
+      operationGroupFile.addFunction(operationDeclaration);
+    });
+
+    operationGroupFile.addImportDeclarations([
+      {
+        moduleSpecifier: "../rest/index.js",
+        namedImports: [`${client.name}Context as Client`, "isUnexpected"]
+      }
+    ]);
+
+    // Import models used from ./models.ts
+    importModels(operationGroupFile, project);
+    operationGroupFile.fixMissingImports();
+  }
+}
+
+function importModels(sourceFile: SourceFile, project: Project) {
+  const modelsFile = project.getSourceFile("models.ts");
+  const models: string[] = [];
+
+  for (const entry of modelsFile?.getExportedDeclarations().entries() ?? []) {
+    models.push(entry[0]);
+  }
+
+  sourceFile.addImportDeclaration({
+    moduleSpecifier: "./models.js",
+    namedImports: models
+  });
+
+  // Import all models and then let ts-morph clean up the unused ones
+  sourceFile.fixUnusedIdentifiers();
+}
+
+/**
+ * This function generates the interfaces for each operation options
+ */
+export function buildOperationOptions(
+  operation: Operation,
+  sourceFile: SourceFile
+) {
+  const optionalParameters = operation.parameters
+    .filter((p) => p.implementation === "Method")
+    .filter((p) => p.optional || p.clientDefaultValue);
+  const optionalBodyParams = (
+    operation.bodyParameter?.type.properties ?? []
+  ).filter((p) => p.optional);
+  const options = [...optionalBodyParams, ...optionalParameters];
+
+  const name = getOperationOptionsName(operation);
+
+  sourceFile.addInterface({
+    name,
+    isExported: true,
+    extends: ["RequestOptions"],
+    properties: options.map((p) => {
+      return {
+        docs: [p.description],
+        hasQuestionToken: true,
+        ...buildType(p.clientName, p.type)
+      };
+    })
+  });
+}

package/src/modular/buildProjectFiles.ts

@@ -0,0 +1,219 @@
+import { Project } from "ts-morph";
+import { ModularCodeModel } from "./modularCodeModel.js";
+
+export function emitPackage(
+  project: Project,
+  srcPath: string,
+  codeModel: ModularCodeModel
+) {
+  const packageJson = project.createSourceFile(
+    `${srcPath}/package-files/package.json`,
+    "",
+    {
+      overwrite: true
+    }
+  );
+  const content = {
+    name: `${
+      codeModel.options?.packageDetails?.name ?? "@msinternal/unamedpackage"
+    }`,
+    version: "1.0.0-beta.1",
+    description: `"${codeModel.options?.packageDetails?.description}"`,
+    "sdk-type": "client",
+    main: "dist/index.js",
+    module: "dist-esm/src/index.js",
+    "react-native": {
+      "./dist/index.js": "./dist-esm/src/index.js"
+    },
+    type: "module",
+    exports: {
+      ".": {
+        types: "./types/src/index.d.ts",
+        require: "./dist/index.cjs",
+        import: "./dist-esm/src/index.js"
+      },
+      "./api": {
+        types: "./types/src/api/index.d.ts",
+        import: "./dist-esm/src/api/index.js"
+      },
+      "./rest": {
+        types: "./types/src/rest/index.d.ts",
+        import: "./dist-esm/src/rest/index.js"
+      }
+    },
+    "//metadata": {
+      constantPaths: [
+        {
+          path: "src/utils/constants.ts",
+          prefix: "SDK_VERSION"
+        }
+      ]
+    },
+    types: `types/latest/${codeModel.options?.packageDetails?.nameWithoutScope}.d.ts`,
+    typesVersions: {
+      "<3.6": {
+        "*": [
+          `types/3.1/${codeModel.options?.packageDetails?.nameWithoutScope}.d.ts`
+        ]
+      }
+    },
+    scripts: {
+      audit:
+        "node ../../../common/scripts/rush-audit.js && rimraf node_modules package-lock.json && npm i --package-lock-only 2>&1 && npm audit",
+      "build:samples": "echo Obsolete",
+      "build:test:browser": "tsc -p . && rollup -c rollup.test.config.js 2>&1",
+      "build:test:node": "tsc -p . && dev-tool run bundle",
+      "build:test": "tsc -p . && rollup -c rollup.test.config.js 2>&1",
+      "build:types": "downlevel-dts types/latest/ types/3.1/",
+      "build:output": "node scripts/renameOutput.mjs",
+      build:
+        "npm run build:test && api-extractor run --local && npm run build:types && npm run build:output",
+      "check-format":
+        'prettier --list-different --config ../../../.prettierrc.json --ignore-path ../../../.prettierignore "src/**/*.ts" "test/**/*.ts" "*.{js,json}"',
+      clean: "rimraf dist dist-* temp types *.tgz *.log",
+      "execute:samples": "dev-tool samples run samples-dev",
+      "extract-api": "tsc -p . && api-extractor run --local",
+      format:
+        'prettier --write --config ../../../.prettierrc.json --ignore-path ../../../.prettierignore "src/**/*.ts" "test/**/*.ts" "samples-dev/**/*.ts" "*.{js,json}"',
+      "integration-test:browser": "echo skipped",
+      "integration-test:node":
+        'nyc mocha --timeout 600000 "test/internal/**/*.spec.ts" "test/public/**/*.spec.ts"',
+      "integration-test":
+        "npm run integration-test:node && npm run integration-test:browser",
+      "lint:fix":
+        "eslint README.md package.json api-extractor.json src test --ext .ts,.javascript,.js --fix --fix-type [problem,suggestion]",
+      lint: "eslint README.md package.json api-extractor.json src test --ext .ts,.javascript,.js",
+      pack: "npm pack 2>&1",
+      "test:browser":
+        "npm run clean && npm run build:test && npm run integration-test:browser",
+      "test:node": "npm run clean && tsc -p . && npm run integration-test:node",
+      test: "npm run clean && tsc -p . && npm run unit-test:node && dev-tool run bundle && npm run unit-test:browser && npm run integration-test",
+      "unit-test:browser": "karma start karma.conf.cjs --single-run",
+      "unit-test:node":
+        'mocha --exclude  "test/**/browser/*.spec.ts" "test/internal/unit/{,!(browser)/**/}*.spec.ts" "test/public/unit/{,!(browser)/**/}*.spec.ts"',
+      "unit-test": "npm run unit-test:node && npm run unit-test:browser"
+    },
+    files: [
+      "dist/",
+      "dist-esm/src/",
+      "types",
+      "types/src",
+      "types/latest/",
+      "types/3.1/",
+      "README.md",
+      "LICENSE"
+    ],
+    repository: "github:Azure/azure-sdk-for-js",
+    engines: {
+      node: ">=14.0.0"
+    },
+    keywords: ["azure", "cloud", "typescript"],
+    author: "Microsoft Corporation",
+    license: "MIT",
+    bugs: {
+      url: "https://github.com/Azure/azure-sdk-for-js/issues"
+    },
+    homepage: `https://github.com/Azure/azure-sdk-for-js/blob/main/sdk/${(
+      codeModel.options?.packageDetails?.nameWithoutScope ?? ""
+    ).replace(/-/g, "")}/${
+      codeModel.options?.packageDetails?.nameWithoutScope
+    }/README.md`,
+    sideEffects: false,
+    prettier: "@azure/eslint-plugin-azure-sdk/prettier.json",
+    devDependencies: {
+      "@azure/dev-tool": "^1.0.0",
+      "@azure/eslint-plugin-azure-sdk": "^3.0.0",
+      "@azure-tools/test-recorder": "^3.0.0",
+      "@azure/test-utils": "^1.0.0",
+      "@microsoft/api-extractor": "^7.31.1",
+      "@rollup/plugin-commonjs": "^24.0.0",
+      "@rollup/plugin-inject": "^5.0.0",
+      "@rollup/plugin-json": "^6.0.0",
+      "@rollup/plugin-multi-entry": "^6.0.0",
+      "@rollup/plugin-node-resolve": "^13.1.3",
+      "@rollup/plugin-replace": "^5.0.0",
+      "@rollup/plugin-typescript": "^11.0.0",
+      "@types/chai": "^4.3.1",
+      "@types/mocha": "^7.0.2",
+      "@types/node": "^14.0.0",
+      chai: "^4.3.6",
+      "cross-env": "^7.0.3",
+      dotenv: "^16.0.0",
+      "downlevel-dts": "^0.10.0",
+      eslint: "^8.16.0",
+      esm: "^3.2.25",
+      karma: "^6.4.0",
+      "karma-chrome-launcher": "^3.1.1",
+      "karma-coverage": "^2.2.0",
+      "karma-edge-launcher": "^0.4.2",
+      "karma-env-preprocessor": "^0.1.1",
+      "karma-firefox-launcher": "^2.1.2",
+      "karma-json-preprocessor": "^0.3.3",
+      "karma-json-to-file-reporter": "^1.0.1",
+      "karma-junit-reporter": "^2.0.1",
+      "karma-mocha": "^2.0.1",
+      "karma-mocha-reporter": "^2.2.5",
+      "karma-sourcemap-loader": "^0.3.8",
+      mocha: "^7.1.1",
+      "mocha-junit-reporter": "^2.0.2",
+      nyc: "^15.1.0",
+      prettier: "^2.5.1",
+      puppeteer: "^19.2.2",
+      rimraf: "^3.0.2",
+      rollup: "^2.0.0",
+      "rollup-plugin-shim": "^1.0.0",
+      "rollup-plugin-sourcemaps": "^0.6.3",
+      "ts-node": "^10.8.1",
+      typescript: "~5.0.0",
+      util: "^0.12.4"
+    },
+    dependencies: {
+      "@azure-rest/core-client": "^1.1.2",
+      "@azure/core-auth": "^1.4.1",
+      "@azure/core-rest-pipeline": "^1.8.1",
+      "@azure/core-util": "^1.1.0",
+      "@azure/logger": "^1.0.3",
+      tslib: "^2.4.0"
+    }
+  };
+
+  packageJson.addStatements(JSON.stringify(content));
+
+  return packageJson;
+}
+
+export function emitTsConfig(
+  project: Project,
+  srcPath: string,
+  codeModel: ModularCodeModel
+) {
+  const tsConfig = project.createSourceFile(
+    `${srcPath}/package-files/tsconfig.json`,
+    "",
+    {
+      overwrite: true
+    }
+  );
+  const content = {
+    extends: "../../../tsconfig.package",
+    compilerOptions: {
+      outDir: "./dist-esm",
+      declarationDir: "./types",
+      paths: {
+        [`${
+          codeModel.options?.packageDetails?.name ?? "@msinternal/unamedpackage"
+        }`]: ["./src/index.js"]
+      },
+      module: "NodeNext",
+      moduleResolution: "NodeNext",
+      rootDir: "."
+    },
+    "ts-node": {
+      esm: true
+    },
+    include: ["src/**/*.ts", "test/**/*.ts", "samples-dev/**/*.ts"]
+  };
+  tsConfig.addStatements(JSON.stringify(content));
+
+  return tsConfig;
+}

package/src/modular/buildRootIndex.ts

@@ -0,0 +1,94 @@
+import { Project, SourceFile } from "ts-morph";
+import { getClientName } from "./helpers/namingHelpers.js";
+import { Client } from "./modularCodeModel.js";
+
+export function buildRootIndex(
+  client: Client,
+  project: Project,
+  srcPath: string
+) {
+  const clientName = `${getClientName(client)}Client`;
+  const clientFile = project.getSourceFile(`${srcPath}/src/${clientName}.ts`);
+
+  if (!clientFile) {
+    throw new Error(
+      `Couldn't find client file: ${srcPath}/src/${clientName}.ts`
+    );
+  }
+
+  const file = project.createSourceFile(`${srcPath}/src/index.ts`, "", {
+    overwrite: true
+  });
+
+  exportModels(file, srcPath);
+  exportOptionsInterfaces(client, file, srcPath);
+  exportClassicalClient(client, file);
+
+  file.addExportDeclarations([
+    {
+      moduleSpecifier: `./common/interfaces.js`,
+      namedExports: [`ClientOptions`, `RequestOptions`]
+    }
+  ]);
+}
+
+function exportClassicalClient(client: Client, indexFile: SourceFile) {
+  const clientName = `${getClientName(client)}Client`;
+  indexFile.addExportDeclaration({
+    namedExports: [clientName],
+    moduleSpecifier: `./${clientName}.js`
+  });
+}
+
+function exportOptionsInterfaces(
+  client: Client,
+  indexFile: SourceFile,
+  srcPath: string
+) {
+  const clientContextName = `${getClientName(client)}Context`;
+  const project = indexFile.getProject();
+  const files = project.getSourceFiles(`${srcPath}/src/api/**`);
+
+  for (const file of files) {
+    if (file.getBaseNameWithoutExtension() === clientContextName) {
+      continue;
+    }
+
+    if (file.getBaseNameWithoutExtension() === "models") {
+      continue;
+    }
+
+    if (file.getBaseNameWithoutExtension() === "index") {
+      continue;
+    }
+
+    const namedExports: string[] = [];
+    for (const [key, delaration] of file.getExportedDeclarations().entries()) {
+      if (
+        delaration[0]?.getKindName() === "InterfaceDeclaration" ||
+        delaration[0]?.getKindName() === "TypeAliasDeclaration"
+      ) {
+        namedExports.push(key);
+      }
+    }
+
+    if (namedExports.length > 0) {
+      const moduleSpecifier = `./api/${file.getBaseNameWithoutExtension()}.js`;
+      indexFile.addExportDeclaration({ moduleSpecifier, namedExports });
+    }
+  }
+}
+
+function exportModels(indexFile: SourceFile, srcPath: string) {
+  const project = indexFile.getProject();
+  const modelsFile = project.getSourceFile(`${srcPath}/src/api/models.ts`);
+
+  if (!modelsFile) {
+    return;
+  }
+
+  const namedExports = [...modelsFile.getExportedDeclarations().keys()];
+  const moduleSpecifier = "./api/models.js";
+
+  indexFile.addExportDeclaration({ moduleSpecifier, namedExports });
+}

package/src/modular/buildSharedTypes.ts

@@ -0,0 +1,40 @@
+import { Project, SourceFile } from "ts-morph";
+
+const content = `import { ClientOptions as RestClientOptions } from "@azure-rest/core-client";
+import { RawHttpHeadersInput } from "@azure/core-rest-pipeline";
+export interface ClientOptions extends RestClientOptions {}
+export interface RequestOptions {
+  requestOptions?: {
+    /**
+     * Headers to send along with the request
+     */
+    headers?: RawHttpHeadersInput;
+    /**
+     * Body to send with the request
+     */
+    body?: unknown;
+    /**
+     * Query parameters to send with the request
+     */
+    queryParameters?: Record<string, unknown>;
+    /** Set to true if the request is sent over HTTP instead of HTTPS */
+    allowInsecureConnection?: boolean;
+    /** Set to true if you want to skip encoding the path parameters */
+    skipUrlEncoding?: boolean;
+  };
+}`;
+
+/**
+ * Creates a file with common interfaces. This should be moved to core
+ */
+export function buildSharedTypes(
+  project: Project,
+  srcPath: string
+): SourceFile {
+  const path = `${srcPath}/src/common/interfaces.ts`;
+  const commonTypes = project.createSourceFile(path, content);
+
+  commonTypes.fixMissingImports({}, { importModuleSpecifierEnding: "js" });
+
+  return commonTypes;
+}

package/src/modular/emitModels.ts

@@ -0,0 +1,72 @@
+import { Project, SourceFile } from "ts-morph";
+import { getType } from "./helpers/typeHelpers.js";
+import { ModularCodeModel } from "./modularCodeModel.js";
+
+/**
+ * This function creates the file containing all the models defined in TypeSpec
+ */
+export function buildModels(
+  codeModel: ModularCodeModel,
+  project: Project,
+  srcPath: string = "src"
+): SourceFile {
+  const modelsFile = project.createSourceFile(`${srcPath}/src/api/models.ts`);
+
+  // We are generating both models and enums here
+  const models = codeModel.types.filter(
+    (t) => t.type === "model" || t.type === "enum"
+  );
+
+  for (const model of models) {
+    const properties = model.properties ?? [];
+    const typeMetadata = getType(model);
+    let typeName = typeMetadata.name;
+    if (typeMetadata.modifier === "Array") {
+      typeName = `${typeName}[]`;
+    }
+    if (model.type === "enum") {
+      modelsFile.addTypeAlias({
+        name: model.name!,
+        isExported: true,
+        docs: [
+          model.description ?? "",
+          // If it is a fixed enum we don't need to list the known values in the docs as the
+          // output will be a literal union which is self documenting
+          model.isFixed
+            ? ""
+            : // When we generate an "extensible" enum, the type will be "string" so we list the known values
+              // in the docs for user reference.
+              (model.values ?? []).map((v) => `"${v.value}"`).join(", ")
+        ],
+        type: model.isFixed
+          ? (model.values ?? []).map((v) => `"${v.value}"`).join(" | ")
+          : "string"
+      });
+    } else {
+      if (!model.name) {
+        throw new Error("Can't generate a model that has no name");
+      }
+      modelsFile.addInterface({
+        name: model.name,
+        isExported: true,
+        docs: [model.description ?? ""],
+        properties: properties.map((p) => {
+          const propertyMetadata = getType(p.type);
+          let propertyTypeName = propertyMetadata.name;
+          if (propertyMetadata.modifier === "Array") {
+            propertyTypeName = `${propertyTypeName}[]`;
+          }
+          return {
+            name: `"${p.clientName}"`,
+            docs: [p.description],
+            hasQuestionToken: p.optional,
+            isReadonly: p.readonly,
+            type: propertyTypeName
+          };
+        })
+      });
+    }
+  }
+
+  return modelsFile;
+}

package/src/modular/helpers/clientHelpers.ts

@@ -0,0 +1,38 @@
+import { OptionalKind, ParameterDeclarationStructure } from "ts-morph";
+import { Client } from "../modularCodeModel.js";
+import { getParameterType } from "./parameterHelpers.js";
+
+export function getClientParameters(
+  client: Client
+): OptionalKind<ParameterDeclarationStructure>[] {
+  const { name, parameters } = client;
+  let optionsParam = {
+    name: "options",
+    type: `${name}Options`,
+    initializer: "{}"
+  };
+  if (
+    !client.parameters
+      .filter((p) => p.implementation === "Client" && !p.isApiVersion)
+      .some((p) => p.optional || (!p.optional && p.clientDefaultValue))
+  ) {
+    optionsParam = {
+      name: "options",
+      type: `ClientOptions`,
+      initializer: "{}"
+    };
+  }
+  const params: OptionalKind<ParameterDeclarationStructure>[] = [
+    ...parameters
+      .filter((p) => p.type.type !== "constant")
+      .map<OptionalKind<ParameterDeclarationStructure>>((p) => {
+        return {
+          name: p.clientName,
+          type: getParameterType(p)
+        };
+      }),
+    optionsParam
+  ];
+
+  return params;
+}

package/src/modular/helpers/credentialHelpers.ts

@@ -0,0 +1,40 @@
+import { SourceFile } from "ts-morph";
+import { Type } from "../modularCodeModel.js";
+
+/**
+ * This function adds an import to the soruce file to import the right credential
+ */
+export function importCredential(
+  credential: Type,
+  clientSourceFile: SourceFile
+): void {
+  switch (credential.type) {
+    case "Key":
+      clientSourceFile.addImportDeclaration({
+        moduleSpecifier: "@azure/core-auth",
+        namedImports: ["AzureKeyCredential"]
+      });
+      return;
+    case "OAuth2":
+      clientSourceFile.addImportDeclaration({
+        moduleSpecifier: "@azure/core-auth",
+        namedImports: ["TokenCredential"]
+      });
+      return;
+    case "combined":
+      if (!credential.types) {
+        break;
+      }
+
+      for (const cred of credential.types) {
+        if (cred.type === "Key" || cred.type === "OAuth2") {
+          importCredential(cred, clientSourceFile);
+        }
+      }
+      break;
+    default:
+      throw new Error(
+        `Credential of type ${credential.type} is not yet supported`
+      );
+  }
+}

package/src/modular/helpers/namingHelpers.ts

@@ -0,0 +1,5 @@
+import { Client } from "../modularCodeModel.js";
+
+export function getClientName(client: Client) {
+  return client.name.replace(/Client$/, "");
+}