@azure-tools/typespec-ts 0.55.0-dev.8 → 0.55.0-dev.9

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

@@ -1,241 +0,0 @@
-// Copyright (c) Microsoft Corporation.
-// Licensed under the MIT License.
-
-import { joinPaths } from "@typespec/compiler";
-import {
-  FunctionDeclarationOverloadStructure,
-  OptionalKind,
-  Project,
-  VariableDeclarationKind,
-} from "ts-morph";
-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({ useInMemoryFileSystem: true });
-  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: `./responses.js`,
-  });
-
-  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

@@ -1,29 +0,0 @@
-// 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;
-  }
-  const project = new Project({ useInMemoryFileSystem: true });
-  const { rlcSourceDir } = model;
-  const { packageDetails } = model.options;
-  const filePath = joinPaths(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

@@ -1,71 +0,0 @@
-// 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);
-    }`;
-}