@azure-tools/typespec-ts 0.55.0-dev.1 → 0.55.0-dev.3

package/src/rlc-common/build-index-file.ts

@@ -0,0 +1,344 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+import { joinPaths } from "@typespec/compiler";
+import { Project, SourceFile } from "ts-morph";
+import { getImportModuleName } from "./helpers/name-constructors.js";
+import { NameType, normalizeName } from "./helpers/name-utils.js";
+import {
+  hasCsvCollection,
+  hasInputModels,
+  hasMultiCollection,
+  hasOutputModels,
+  hasPagingOperations,
+  hasPipeCollection,
+  hasPollingOperations,
+  hasSsvCollection,
+  hasTsvCollection,
+  hasUnexpectedHelper,
+} from "./helpers/operation-helpers.js";
+import { isAzurePackage } from "./helpers/package-util.js";
+import { RLCModel } from "./interfaces.js";
+
+export function buildIndexFile(model: RLCModel) {
+  const multiClient = Boolean(model.options?.multiClient),
+    batch = model.options?.batch;
+  const project = new Project();
+  const { srcPath } = model;
+  const filePath = joinPaths(srcPath, `index.ts`);
+  const indexFile = project.createSourceFile(filePath, undefined, {
+    overwrite: true,
+  });
+
+  if (!multiClient || !batch || batch?.length === 1) {
+    // if we are generate single client package for RLC
+    generateRLCIndex(indexFile, model);
+  } else {
+    generateRLCIndexForMultiClient(indexFile, model);
+  }
+  return {
+    path: filePath,
+    content: indexFile.getFullText(),
+  };
+}
+
+// to generate a index.ts for each single module inside the multi client RLC package
+function generateRLCIndexForMultiClient(file: SourceFile, model: RLCModel) {
+  const clientName = model.libraryName;
+  const createClientFuncName = `createClient`;
+  const moduleName = normalizeName(clientName, NameType.File);
+
+  file.addImportDeclaration({
+    namespaceImport: "Parameters",
+    moduleSpecifier: getImportModuleName(
+      { cjsName: "./parameters", esModulesName: "./parameters.js" },
+      model,
+    ),
+  });
+
+  file.addImportDeclaration({
+    namespaceImport: "Responses",
+    moduleSpecifier: getImportModuleName(
+      { cjsName: "./responses", esModulesName: "./responses.js" },
+      model,
+    ),
+  });
+
+  file.addImportDeclaration({
+    namespaceImport: "Client",
+    moduleSpecifier: getImportModuleName(
+      {
+        cjsName: "./clientDefinitions",
+        esModulesName: "./clientDefinitions.js",
+      },
+      model,
+    ),
+  });
+
+  const exports = ["Parameters", "Responses", "Client"];
+  if (hasInputModels(model)) {
+    file.addImportDeclaration({
+      namespaceImport: "Models",
+      moduleSpecifier: getImportModuleName(
+        {
+          cjsName: "./models",
+          esModulesName: "./models.js",
+        },
+        model,
+      ),
+    });
+    exports.push("Models");
+  }
+
+  if (hasOutputModels(model)) {
+    file.addImportDeclaration({
+      namespaceImport: "OutputModels",
+      moduleSpecifier: getImportModuleName(
+        {
+          cjsName: "./outputModels",
+          esModulesName: "./outputModels.js",
+        },
+        model,
+      ),
+    });
+    exports.push("OutputModels");
+  }
+
+  if (hasPagingOperations(model)) {
+    file.addImportDeclaration({
+      namespaceImport: "PaginateHelper",
+      moduleSpecifier: getImportModuleName(
+        {
+          cjsName: "./paginateHelper",
+          esModulesName: "./paginateHelper.js",
+        },
+        model,
+      ),
+    });
+    exports.push("PaginateHelper");
+  }
+
+  if (hasUnexpectedHelper(model)) {
+    file.addImportDeclaration({
+      namespaceImport: "UnexpectedHelper",
+      moduleSpecifier: getImportModuleName(
+        {
+          cjsName: "./isUnexpected",
+          esModulesName: "./isUnexpected.js",
+        },
+        model,
+      ),
+    });
+    exports.push("UnexpectedHelper");
+  }
+
+  if (hasPollingOperations(model)) {
+    file.addImportDeclaration({
+      namespaceImport: "PollingHelper",
+      moduleSpecifier: getImportModuleName(
+        {
+          cjsName: "./pollingHelper",
+          esModulesName: "./pollingHelper.js",
+        },
+        model,
+      ),
+    });
+    exports.push("PollingHelper");
+  }
+
+  if (
+    hasMultiCollection(model) ||
+    hasSsvCollection(model) ||
+    hasPipeCollection(model) ||
+    hasTsvCollection(model) ||
+    hasCsvCollection(model)
+  ) {
+    file.addImportDeclaration({
+      namespaceImport: "SerializeHelper",
+      moduleSpecifier: getImportModuleName(
+        {
+          cjsName: "./serializeHelper",
+          esModulesName: "./serializeHelper.js",
+        },
+        model,
+      ),
+    });
+    exports.push("SerializeHelper");
+  }
+
+  file.addExportDeclarations([
+    {
+      moduleSpecifier: getImportModuleName(
+        {
+          cjsName: `./${moduleName}`,
+          esModulesName: `./${moduleName}.js`,
+        },
+        model,
+      ),
+      namedExports: [`${createClientFuncName}`, `${clientName}ClientOptions`],
+    },
+    {
+      namedExports: [...exports],
+    },
+  ]);
+}
+
+function generateRLCIndex(file: SourceFile, model: RLCModel) {
+  const clientName = model.libraryName;
+  const createClientFuncName = `${clientName}`;
+  const moduleName = normalizeName(clientName, NameType.File);
+
+  file.addImportDeclaration({
+    moduleSpecifier: getImportModuleName(
+      {
+        cjsName: `./${moduleName}`,
+        esModulesName: `./${moduleName}.js`,
+      },
+      model,
+    ),
+    defaultImport: createClientFuncName,
+  });
+
+  file.addExportDeclarations([
+    {
+      moduleSpecifier: getImportModuleName(
+        {
+          cjsName: `./${moduleName}`,
+          esModulesName: `./${moduleName}.js`,
+        },
+        model,
+      ),
+    },
+    {
+      moduleSpecifier: getImportModuleName(
+        {
+          cjsName: `./parameters`,
+          esModulesName: `./parameters.js`,
+        },
+        model,
+      ),
+    },
+    {
+      moduleSpecifier: getImportModuleName(
+        {
+          cjsName: `./responses`,
+          esModulesName: `./responses.js`,
+        },
+        model,
+      ),
+    },
+    {
+      moduleSpecifier: getImportModuleName(
+        {
+          cjsName: `./clientDefinitions`,
+          esModulesName: `./clientDefinitions.js`,
+        },
+        model,
+      ),
+    },
+  ]);
+
+  if (hasUnexpectedHelper(model)) {
+    file.addExportDeclarations([
+      {
+        moduleSpecifier: getImportModuleName(
+          {
+            cjsName: `./isUnexpected`,
+            esModulesName: `./isUnexpected.js`,
+          },
+          model,
+        ),
+      },
+    ]);
+  }
+
+  if (hasInputModels(model)) {
+    file.addExportDeclarations([
+      {
+        moduleSpecifier: getImportModuleName(
+          {
+            cjsName: `./models`,
+            esModulesName: `./models.js`,
+          },
+          model,
+        ),
+      },
+    ]);
+  }
+
+  if (hasOutputModels(model)) {
+    file.addExportDeclarations([
+      {
+        moduleSpecifier: getImportModuleName(
+          {
+            cjsName: `./outputModels`,
+            esModulesName: `./outputModels.js`,
+          },
+          model,
+        ),
+      },
+    ]);
+  }
+
+  if (hasPagingOperations(model)) {
+    file.addExportDeclarations([
+      {
+        moduleSpecifier: getImportModuleName(
+          {
+            cjsName: `./paginateHelper`,
+            esModulesName: `./paginateHelper.js`,
+          },
+          model,
+        ),
+      },
+    ]);
+  }
+
+  if (hasPollingOperations(model)) {
+    file.addExportDeclarations([
+      {
+        moduleSpecifier: getImportModuleName(
+          {
+            cjsName: `./pollingHelper`,
+            esModulesName: `./pollingHelper.js`,
+          },
+          model,
+        ),
+      },
+    ]);
+  }
+
+  if (
+    hasMultiCollection(model) ||
+    hasSsvCollection(model) ||
+    hasPipeCollection(model) ||
+    hasTsvCollection(model) ||
+    hasCsvCollection(model)
+  ) {
+    file.addExportDeclarations([
+      {
+        moduleSpecifier: getImportModuleName(
+          {
+            cjsName: `./serializeHelper`,
+            esModulesName: `./serializeHelper.js`,
+          },
+          model,
+        ),
+      },
+    ]);
+  }
+
+  if (isAzurePackage(model)) {
+    file.addExportDeclarations([
+      {
+        moduleSpecifier: "@azure/core-rest-pipeline",
+        namedExports: ["RestError", "isRestError"],
+      },
+    ]);
+  }
+
+  file.addExportAssignment({
+    expression: createClientFuncName,
+    isExportEquals: false,
+  });
+}

package/src/rlc-common/build-is-unexpected-helper.ts

@@ -0,0 +1,248 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+import { joinPaths } from "@typespec/compiler";
+import {
+  FunctionDeclarationOverloadStructure,
+  OptionalKind,
+  Project,
+  VariableDeclarationKind,
+} from "ts-morph";
+import { getImportModuleName } from "./helpers/name-constructors.js";
+import { hasUnexpectedHelper } from "./helpers/operation-helpers.js";
+import { RLCModel } from "./interfaces.js";
+export function buildIsUnexpectedHelper(model: RLCModel) {
+  if (!hasUnexpectedHelper(model)) {
+    return;
+  }
+  const project = new Project();
+  const srcPath = model.srcPath;
+  const filePath = joinPaths(srcPath, `isUnexpected.ts`);
+  const isErrorHelper = project.createSourceFile(filePath, undefined, {
+    overwrite: true,
+  });
+
+  let map: Record<string, string[]> = {};
+  const allResponseTypes: Set<string> = new Set();
+  const allErrorTypes: Set<string> = new Set();
+  const overloads: OptionalKind<FunctionDeclarationOverloadStructure>[] = [];
+  const pathDictionary = model.paths;
+
+  for (const [path, details] of Object.entries(pathDictionary)) {
+    for (const [methodName, methodDetails] of Object.entries(details.methods)) {
+      const originalMethod = methodName.toUpperCase();
+      const operation = `${originalMethod} ${path}`;
+      const successCodeSet = new Set<string>(map["operation"] ?? []);
+      for (const detail of methodDetails) {
+        detail.successStatus.forEach(successCodeSet.add, successCodeSet);
+        // LROs may call the same path but with GET
+        // to get the operation status.
+        if (detail.operationHelperDetail?.lroDetails?.isLongRunning && originalMethod !== "GET") {
+          const operation = `GET ${path}`;
+          const logicalSuccessCodes = detail.operationHelperDetail?.lroDetails?.logicalResponseTypes
+            ?.success
+            ? ["200"]
+            : [];
+          const initialSuccessCodes =
+            (pathDictionary[path]?.methods["get"] &&
+              pathDictionary[path]?.methods["get"]?.[0]?.successStatus) ??
+            detail.successStatus;
+          map = {
+            ...map,
+            ...{
+              [operation]: Array.from(new Set(logicalSuccessCodes.concat(initialSuccessCodes))),
+            },
+          };
+        }
+
+        const successTypes = [...detail.responseTypes.success];
+        const errorTypes = [...detail.responseTypes.error];
+
+        if (
+          model.helperDetails?.clientLroOverload &&
+          detail.operationHelperDetail?.lroDetails?.logicalResponseTypes?.success
+        ) {
+          successTypes.push(
+            ...(detail.operationHelperDetail.lroDetails.logicalResponseTypes.success ?? []),
+          );
+        }
+
+        if (!successTypes.length || !errorTypes.length || !errorTypes[0]) {
+          continue;
+        }
+
+        successTypes.forEach((t) => allResponseTypes.add(t));
+        errorTypes.forEach((t) => {
+          allResponseTypes.add(t);
+          allErrorTypes.add(t);
+        });
+
+        overloads.push({
+          isExported: true,
+          parameters: [
+            {
+              name: "response",
+              type: [...successTypes, ...errorTypes].join(" | "),
+            },
+          ],
+          returnType: `response is ${errorTypes[0]}`,
+        });
+      }
+      map = { ...map, ...{ [operation]: Array.from(successCodeSet) } };
+    }
+  }
+  isErrorHelper.addImportDeclaration({
+    isTypeOnly: true,
+    namedImports: [...allResponseTypes],
+    moduleSpecifier: getImportModuleName(
+      {
+        cjsName: `./responses`,
+        esModulesName: `./responses.js`,
+      },
+      model,
+    ),
+  });
+
+  isErrorHelper.addVariableStatement({
+    declarations: [
+      {
+        name: "responseMap",
+        initializer: JSON.stringify(map),
+        type: "Record<string, string[]>",
+      },
+    ],
+    declarationKind: VariableDeclarationKind.Const,
+  });
+
+  if (allErrorTypes.size) {
+    isErrorHelper.addFunction({
+      overloads,
+      isExported: true,
+      name: "isUnexpected",
+      parameters: [
+        {
+          name: "response",
+          type: [...allResponseTypes].join(" | "),
+        },
+      ],
+      returnType: `response is ${[...allErrorTypes].join(" | ")}`,
+      statements: [
+        `
+          const lroOriginal = response.headers["x-ms-original-url"];
+          const url = new URL(lroOriginal ?? response.request.url);
+          const method = response.request.method;
+          let pathDetails = responseMap[\`\${method} \${url.pathname}\`];
+          if (!pathDetails) {
+            pathDetails = getParametrizedPathSuccess(method, url.pathname);
+          }
+          return !pathDetails.includes(response.status);
+        `,
+      ],
+    });
+    isErrorHelper.addFunction({
+      isExported: false,
+      name: "getParametrizedPathSuccess",
+      parameters: [
+        {
+          name: "method",
+          type: "string",
+        },
+        {
+          name: "path",
+          type: "string",
+        },
+      ],
+      returnType: `string[]`,
+      statements: [
+        `
+          const pathParts = path.split("/");
+            
+          // Traverse list to match the longest candidate
+          // matchedLen: the length of candidate path
+          // matchedValue: the matched status code array
+          let matchedLen = -1,
+            matchedValue: string[] = [];
+          
+          // Iterate the responseMap to find a match
+          for (const [key, value] of Object.entries(responseMap)) {
+            // Extracting the path from the map key which is in format
+            // GET /path/foo
+            if (!key.startsWith(method)) {
+              continue;
+            }
+            const candidatePath = getPathFromMapKey(key);
+            // Get each part of the url path
+            const candidateParts = candidatePath.split("/");
+        
+            // track if we have found a match to return the values found.
+            let found = true;
+            for (
+              let i = candidateParts.length - 1, j = pathParts.length - 1;
+              i >= 1 && j >= 1;
+              i--, j--
+            ) {
+              if (
+                candidateParts[i]?.startsWith("{") &&
+                candidateParts[i]?.indexOf("}") !== -1
+              ) {
+                const start = candidateParts[i]!.indexOf("}") + 1,
+                  end = candidateParts[i]?.length;
+                // If the current part of the candidate is a "template" part
+                // Try to use the suffix of pattern to match the path
+                // {guid} ==> $
+                // {guid}:export ==> :export$
+                const isMatched = new RegExp(
+                  \`\${candidateParts[i]?.slice(start, end)}\`
+                ).test(pathParts[j] || '');
+        
+                if (!isMatched) {
+                  found = false;
+                  break;
+                }
+                continue;
+              }
+        
+              // If the candidate part is not a template and
+              // the parts don't match mark the candidate as not found
+              // to move on with the next candidate path.
+              if (candidateParts[i] !== pathParts[j]) {
+                found = false;
+                break;
+              }
+            }
+        
+            // We finished evaluating the current candidate parts
+            // Update the matched value if and only if we found the longer pattern
+            if (found && candidatePath.length > matchedLen) {
+              matchedLen = candidatePath.length;
+              matchedValue = value;
+            }
+          }
+        
+          return matchedValue;
+        `,
+      ],
+    });
+
+    isErrorHelper.addFunction({
+      isExported: false,
+      name: "getPathFromMapKey",
+      parameters: [
+        {
+          name: "mapKey",
+          type: "string",
+        },
+      ],
+      returnType: `string`,
+      statements: [
+        `const pathStart = mapKey.indexOf("/");
+         return mapKey.slice(pathStart);`,
+      ],
+    });
+  }
+
+  return {
+    path: filePath,
+    content: isErrorHelper.getFullText(),
+  };
+}

package/src/rlc-common/build-logger.ts

@@ -0,0 +1,43 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+import { joinPaths } from "@typespec/compiler";
+import { Project } from "ts-morph";
+import { RLCModel } from "./interfaces.js";
+
+export function buildLogger(model: RLCModel) {
+  if (!model.options) {
+    return undefined;
+  }
+  // Disable logger for non-Azure packages
+  if (model.options.flavor !== "azure") {
+    return undefined;
+  }
+  const project = new Project();
+  const { srcPath, rlcSourceDir } = model;
+  const { packageDetails } = model.options;
+  const filePath = joinPaths(
+    model.options.sourceFrom === "Swagger"
+      ? srcPath.substring(
+          0,
+          srcPath.includes("generated") && !srcPath.includes("src")
+            ? srcPath.lastIndexOf("generated") + 10
+            : srcPath.lastIndexOf("src") + 4,
+        )
+      : rlcSourceDir!,
+    `logger.ts`,
+  );
+  const loggerFile = project.createSourceFile("logger.ts", undefined, {
+    overwrite: true,
+  });
+  loggerFile.addImportDeclaration({
+    namedImports: ["createClientLogger"],
+    moduleSpecifier: `@azure/logger`,
+  });
+  loggerFile.addStatements(
+    `export const logger = createClientLogger("${
+      packageDetails!.nameWithoutScope ?? packageDetails?.name ?? ""
+    }")`,
+  );
+  return { path: filePath, content: loggerFile.getFullText() };
+}

package/src/rlc-common/build-method-shortcuts.ts

@@ -0,0 +1,71 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+import { CasingConvention, NameType, normalizeName, ReservedName } from "./helpers/name-utils.js";
+import { PathMetadata, PathParameter, Paths } from "./interfaces.js";
+
+export const REST_CLIENT_RESERVED: ReservedName[] = [
+  { name: "path", reservedFor: [NameType.Property, NameType.OperationGroup] },
+  {
+    name: "pathUnchecked",
+    reservedFor: [NameType.Property, NameType.OperationGroup],
+  },
+  {
+    name: "pipeline",
+    reservedFor: [NameType.Property, NameType.OperationGroup],
+  },
+];
+
+export function buildMethodShortcutImplementation(paths: Paths) {
+  const keys: Record<string, string[]> = {};
+  for (const path of Object.keys(paths)) {
+    const pathMetadata = paths[path];
+    if (!pathMetadata) {
+      continue;
+    }
+    const groupName = normalizeName(
+      pathMetadata.operationGroupName,
+      NameType.OperationGroup,
+      true,
+      REST_CLIENT_RESERVED,
+      CasingConvention.Camel,
+    );
+
+    if (keys[groupName]) {
+      keys[groupName].push(...buildOperationDeclarations(path, pathMetadata));
+    } else {
+      keys[groupName] = buildOperationDeclarations(path, pathMetadata);
+    }
+  }
+  return keys;
+}
+
+function buildOperationDeclarations(path: string, pathMetadata: PathMetadata) {
+  let ops: string[] = [];
+  for (const method of Object.keys(pathMetadata.methods)) {
+    const methodOps = pathMetadata.methods[method];
+    if (!methodOps) {
+      continue;
+    }
+    for (const op of methodOps) {
+      const pathParams = pathMetadata?.pathParameters;
+      const name = normalizeName(op.operationName, NameType.Property);
+      const methodDefinitions = generateOperationDeclaration(path, name, method, pathParams);
+      ops = [...ops, methodDefinitions];
+    }
+  }
+
+  return ops;
+}
+
+function generateOperationDeclaration(
+  path: string,
+  operationName: string,
+  method: string,
+  pathParams: PathParameter[] = [],
+): string {
+  const pathParamNames = `${pathParams.length > 0 ? `${pathParams.map((p) => p.name)},` : ""}`;
+  return `"${operationName}": (${pathParamNames} options) => {
+      return client.path("${path}", ${pathParamNames}).${method}(options);
+    }`;
+}