@azure-tools/typespec-ts 0.53.3 → 0.54.0

package/src/rlc-common/buildIsUnexpectedHelper.ts

@@ -0,0 +1,255 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+import { RLCModel } from "./interfaces.js";
+import * as path from "path";
+import {
+  FunctionDeclarationOverloadStructure,
+  OptionalKind,
+  Project,
+  VariableDeclarationKind
+} from "ts-morph";
+import { hasUnexpectedHelper } from "./helpers/operationHelpers.js";
+import { getImportModuleName } from "./helpers/nameConstructors.js";
+export function buildIsUnexpectedHelper(model: RLCModel) {
+  if (!hasUnexpectedHelper(model)) {
+    return;
+  }
+  const project = new Project();
+  const srcPath = model.srcPath;
+  const filePath = path.join(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/buildLogger.ts

@@ -0,0 +1,43 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+import { RLCModel } from "./interfaces.js";
+import { Project } from "ts-morph";
+import * as path from "path";
+
+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 = path.join(
+    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/buildMethodShortcuts.ts

@@ -0,0 +1,83 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+import {
+  CasingConvention,
+  NameType,
+  normalizeName,
+  ReservedName
+} from "./helpers/nameUtils.js";
+import { Paths, PathParameter, PathMetadata } 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);
+    }`;
+}