@azure-tools/typespec-ts 0.54.2 → 0.55.0-dev.10

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

@@ -1,344 +0,0 @@
-// Copyright (c) Microsoft Corporation.
-// Licensed under the MIT License.
-
-import * as path from "path";
-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 = path.join(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

@@ -1,248 +0,0 @@
-// Copyright (c) Microsoft Corporation.
-// Licensed under the MIT License.
-
-import * as path from "path";
-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 = 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/build-logger.ts

@@ -1,43 +0,0 @@
-// Copyright (c) Microsoft Corporation.
-// Licensed under the MIT License.
-
-import * as path from "path";
-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 = 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/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);
-    }`;
-}