@azure-tools/typespec-ts 0.54.0 → 0.54.2

package/src/rlc-common/test/buildRecordedClient.ts

@@ -1,18 +0,0 @@
-// eslint-disable-next-line @typescript-eslint/ban-ts-comment
-// @ts-ignore: to fix the handlebars issue
-import hbs from "handlebars";
-import { RLCModel } from "../interfaces.js";
-import { recordedClientContent } from "./template.js";
-
-export function buildRecordedClientFile(model: RLCModel) {
-  const recordedClientFileContents = hbs.compile(recordedClientContent, {
-    noEscape: true
-  });
-  return {
-    path: "test/public/utils/recordedClient.ts",
-    content: recordedClientFileContents({
-      isEsm: model.options?.moduleKind === "esm",
-      isCjs: model.options?.moduleKind === "cjs"
-    })
-  };
-}

package/src/rlc-common/test/buildSampleTest.ts

@@ -1,15 +0,0 @@
-// eslint-disable-next-line @typescript-eslint/ban-ts-comment
-// @ts-ignore: to fix the handlebars issue
-import hbs from "handlebars";
-import { sampleTestContent } from "./template.js";
-import { RLCModel } from "../interfaces.js";
-
-export function buildSampleTest(model: RLCModel) {
-  return {
-    path: "test/public/sampleTest.spec.ts",
-    content: hbs.compile(sampleTestContent, { noEscape: true })({
-      isEsm: model.options?.moduleKind === "esm",
-      isCjs: model.options?.moduleKind === "cjs"
-    })
-  };
-}

package/src/rlc-common/test/buildSnippets.ts

@@ -1,35 +0,0 @@
-// eslint-disable-next-line @typescript-eslint/ban-ts-comment
-// @ts-ignore: to fix the handlebars issue
-import hbs from "handlebars";
-import { snippetsContent } from "./template.js";
-import { RLCModel } from "../interfaces.js";
-import { getClientName } from "../helpers/nameConstructors.js";
-
-export function buildSnippets(
-  model: RLCModel,
-  clientName?: string,
-  azureSdkForJs?: boolean
-) {
-  const azureSdkForJsInfo = azureSdkForJs
-    ? azureSdkForJs
-    : model.options?.azureSdkForJs;
-  // to keep the same config for azure scope in buildReadmeFile.ts
-  if (
-    (model?.options?.packageDetails?.scopeName === "azure" ||
-      model?.options?.packageDetails?.scopeName === "azure-rest") &&
-    model.options.addCredentials &&
-    azureSdkForJsInfo
-  ) {
-    return {
-      path: "test/snippets.spec.ts",
-      content: hbs.compile(snippetsContent, { noEscape: true })({
-        clientClassName: clientName ? clientName : getClientName(model),
-        azureArm: model.options?.azureArm,
-        azureSdkForJs: azureSdkForJsInfo,
-        isModularLibrary: model.options.isModularLibrary,
-        hasSubscriptionId: model.options.hasSubscriptionId
-      })
-    };
-  }
-  return undefined;
-}

package/src/rlc-common/transformSampleGroups.ts

@@ -1,458 +0,0 @@
-import { generateParameterTypeValue } from "./helpers/valueGenerationUtil.js";
-import { getClientName } from "./helpers/nameConstructors.js";
-import { normalizeName, NameType, camelCase } from "./helpers/nameUtils.js";
-import { buildSchemaObjectMap } from "./helpers/schemaHelpers.js";
-import {
-  RLCModel,
-  RLCSampleGroup,
-  Paths,
-  OperationMethod,
-  RLCSampleDetail,
-  SampleParameters,
-  SampleParameter,
-  Schema,
-  PathMetadata,
-  OperationParameter
-} from "./interfaces.js";
-import { isAzurePackage } from "./helpers/packageUtil.js";
-
-/**
- * Transform the sample data based RLC detail e.g path, operations & schemas
- * @param model RLC detail
- * @param allowMockValue allow to mock value if not exist, currently we always generate mock value
- * @returns Generated sample data or undefined if not support to generate
- */
-export function transformSampleGroups(model: RLCModel, allowMockValue = true) {
-  if (model.options?.multiClient || model.options?.isModularLibrary) {
-    // Not support to generate if multiple clients
-    // Not support to generate if modular libraries
-    return;
-  }
-  if (
-    (model.sampleGroups && model.sampleGroups.length > 0) ||
-    !allowMockValue
-  ) {
-    // Skip to transform if already has sample data
-    // Skip to transform if not allow to mock value
-    return;
-  }
-  const rlcSampleGroups: RLCSampleGroup[] = [];
-  // Get all paths
-  const paths: Paths = model.paths;
-  const clientName = getClientName(model);
-  const clientInterfaceName = clientName.endsWith("Client")
-    ? `${clientName}`
-    : `${clientName}Client`;
-  const defaultFactoryName = normalizeName(
-    camelCase(`create ${clientInterfaceName}`),
-    NameType.Method
-  );
-  const packageName = model.options?.packageDetails?.name ?? "";
-  const methodParameterMap = buildMethodParamMap(model);
-  const schemaObjectMap = buildSchemaObjectMap(model);
-  for (const path in paths) {
-    const pathDetails = paths[path];
-    if (!pathDetails) {
-      continue;
-    }
-    const methods = pathDetails.methods;
-    for (const method in methods) {
-      const importedDict: Record<string, Set<string>> = {};
-      const methodArray = methods[method];
-      if (!methodArray || methodArray.length === 0) {
-        continue;
-      }
-      const detail = methodArray[0];
-      if (!detail) {
-        continue;
-      }
-      const operatonConcante = getOperationConcate(
-        detail.operationName,
-        pathDetails.operationGroupName,
-        model.options?.sourceFrom
-      );
-      const operationPrefix = normalizeName(
-        camelCase(transformSpecialLetterToSpace(operatonConcante)),
-        NameType.Operation
-      );
-      const sampleGroup: RLCSampleGroup = {
-        filename: `${operationPrefix}Sample`,
-        defaultFactoryName,
-        clientPackageName: packageName,
-        samples: []
-      };
-
-      // initialize the sample
-      const sample: RLCSampleDetail = {
-        description: `call operation ${detail.operationName}`,
-        name: `${operationPrefix}Sample`,
-        path,
-        defaultFactoryName,
-        clientParamAssignments: [],
-        pathParamAssignments: [],
-        methodParamAssignments: [],
-        clientParamNames: "",
-        pathParamNames: "",
-        methodParamNames: "",
-        method,
-        isLRO: detail.operationHelperDetail?.lroDetails?.isLongRunning ?? false,
-        isPaging: detail.operationHelperDetail?.isPaging ?? false,
-        useLegacyLro: false
-      };
-      // client-level, path-level and method-level parameter preparation
-      const parameters: SampleParameters = {
-        client: convertClientLevelParameters(
-          model,
-          importedDict,
-          schemaObjectMap
-        ),
-        path: convertPathLevelParameters(pathDetails, path, schemaObjectMap),
-        method: convertMethodLevelParameters(
-          methodArray,
-          schemaObjectMap,
-          methodParameterMap.get(operatonConcante)
-        )
-      };
-      // enrich parameter details
-      enrichParameterInSample(sample, parameters);
-      // enrich LRO and pagination info
-      enrichLROAndPagingInSample(detail, importedDict, packageName);
-      sampleGroup.samples.push(sample);
-      rlcSampleGroups.push(sampleGroup);
-      enrichImportedString(
-        sampleGroup,
-        importedDict,
-        defaultFactoryName,
-        packageName
-      );
-    }
-  }
-  return rlcSampleGroups;
-}
-
-function enrichLROAndPagingInSample(
-  operation: OperationMethod,
-  importedDict: Record<string, Set<string>>,
-  packageName: string
-) {
-  const isLRO =
-      operation.operationHelperDetail?.lroDetails?.isLongRunning ?? false,
-    isPaging = operation.operationHelperDetail?.isPaging ?? false;
-  if (isPaging) {
-    if (isLRO) {
-      // TODO: report warning this is not supported
-    }
-    addValueInImportedDict(packageName, "paginate", importedDict);
-  } else if (isLRO) {
-    addValueInImportedDict(packageName, "getLongRunningPoller", importedDict);
-  }
-}
-
-function transformSpecialLetterToSpace(str: string) {
-  if (!str) {
-    return str;
-  }
-  return str
-    .replace(/_/g, " ")
-    .replace(/\//g, " Or ")
-    .replace(/,|\.|\(|\)/g, " ")
-    .replace("'s ", " ");
-}
-
-function enrichImportedString(
-  sampleGroup: RLCSampleGroup,
-  importedDict: Record<string, Set<string>>,
-  defaultFactoryName: string,
-  packageName: string
-) {
-  const importedTypes: string[] = [];
-  if (!importedDict[packageName] || importedDict[packageName].size === 0) {
-    importedTypes.push(`import ${defaultFactoryName} from "${packageName}";`);
-  }
-  for (const key in importedDict) {
-    const importedSet = importedDict[key];
-    if (!importedSet) {
-      continue;
-    }
-    const values = Array.from(importedSet).join(", ");
-    const hasDefaultFactory =
-      key === packageName ? `${defaultFactoryName},` : "";
-    importedTypes.push(
-      `import ${hasDefaultFactory} { ${values} } from "${key}";`
-    );
-  }
-  sampleGroup.importedTypes = importedTypes;
-}
-
-function enrichParameterInSample(
-  sample: RLCSampleDetail,
-  parameters: SampleParameters
-) {
-  sample.clientParamAssignments = getAssignmentStrArray(parameters.client);
-  sample.clientParamNames = getContactParameterNames(parameters.client);
-  sample.pathParamAssignments = getAssignmentStrArray(parameters.path);
-  sample.pathParamNames = getContactParameterNames(parameters.path);
-  // Directly apply the inline option value as method parameter
-  sample.methodParamNames =
-    parameters.method.length > 0 ? (parameters.method[0]?.value ?? "") : "";
-}
-
-function getAssignmentStrArray(parameters: SampleParameter[]) {
-  return parameters.filter((p) => !!p.assignment).map((p) => p.assignment!);
-}
-
-function getContactParameterNames(parameters: SampleParameter[]) {
-  return parameters
-    .filter((p) => p.name != null)
-    .map((p) => p.name!)
-    .join(",");
-}
-
-function convertClientLevelParameters(
-  model: RLCModel,
-  importedDict: Record<string, Set<string>>,
-  schemaMap: Map<string, Schema>
-): SampleParameter[] {
-  if (!model.options) {
-    return [];
-  }
-  const clientParams: SampleParameter[] = [];
-  const urlParameters = model?.urlInfo?.urlParameters?.filter(
-    // Do not include parameters with constant values in the signature, these should go in the options bag
-    (p) => p.value === undefined
-  );
-  const {
-    addCredentials,
-    credentialScopes,
-    credentialKeyHeaderName,
-    customHttpAuthHeaderName,
-    flavor
-  } = model.options;
-  const hasUrlParameter = !!urlParameters,
-    hasCredentials =
-      addCredentials &&
-      (credentialScopes || credentialKeyHeaderName || customHttpAuthHeaderName);
-
-  if (hasUrlParameter) {
-    // convert the host parameters in url
-    const clientParamAssignments = urlParameters.map((urlParameter) => {
-      const urlValue = generateParameterTypeValue(
-        urlParameter.type,
-        urlParameter.name,
-        schemaMap
-      );
-      const normalizedName = normalizeName(
-        urlParameter.name,
-        NameType.Parameter
-      );
-      return {
-        name: normalizedName,
-        assignment: `const ${normalizedName} = ` + urlValue + `;`
-      };
-    });
-
-    clientParams.push(...clientParamAssignments);
-  }
-  if (hasCredentials) {
-    // Currently only support token credential
-    const apiKeyCredentialPackage = isAzurePackage(model)
-      ? "@azure/core-auth"
-      : "@typespec/ts-http-runtime";
-    const tokenCredentialPackage = isAzurePackage(model)
-      ? "@azure/identity"
-      : "@typespec/ts-http-runtime";
-    if (credentialKeyHeaderName && isAzurePackage(model)) {
-      clientParams.push({
-        name: "credential",
-        assignment: `const credential = new AzureKeyCredential("{Your API key}");`
-      });
-      addValueInImportedDict(
-        apiKeyCredentialPackage,
-        "AzureKeyCredential",
-        importedDict
-      );
-    } else if (
-      (credentialKeyHeaderName && flavor !== "azure") ||
-      customHttpAuthHeaderName
-    ) {
-      clientParams.push({
-        name: "credential",
-        assignment: `const credential = { key: "{Your API key}"};`
-      });
-    } else if (isAzurePackage(model)) {
-      clientParams.push({
-        name: "credential",
-        assignment: "const credential = new DefaultAzureCredential();"
-      });
-      addValueInImportedDict(
-        tokenCredentialPackage,
-        "DefaultAzureCredential",
-        importedDict
-      );
-    } else {
-      clientParams.push({
-        name: "credential",
-        assignment: `const credential = {getToken: () => Promise.resolve({ token: "{Your token}", expiresOnTimestamp: 0 })};`
-      });
-    }
-  }
-  return clientParams;
-}
-
-function convertPathLevelParameters(
-  pathDetail: PathMetadata,
-  path: string,
-  schemaMap: Map<string, Schema>
-): SampleParameter[] {
-  const pathItself = {
-    name: `"${path}"`
-  };
-  const pathParams = (pathDetail || []).pathParameters.map((p) => {
-    const pathParam: SampleParameter = {
-      name: normalizeName(p.name, NameType.Parameter)
-    };
-    const value = generateParameterTypeValue(p.type, p.name, schemaMap);
-    pathParam.assignment = `const ${pathParam.name} =` + value + `;`;
-    return pathParam;
-  });
-  return [pathItself].concat(pathParams);
-}
-
-function convertMethodLevelParameters(
-  methods: OperationMethod[],
-  schemaMap: Map<string, Schema>,
-  operationParameter?: OperationParameter
-): SampleParameter[] {
-  if (
-    !methods ||
-    methods.length === 0 ||
-    !operationParameter ||
-    operationParameter.parameters.length === 0
-  ) {
-    return [];
-  }
-  const rawMethodParams = operationParameter.parameters;
-  const method = methods[0];
-  const requestParameter = rawMethodParams[0];
-  if (!method || !requestParameter) {
-    return [];
-  }
-  const hasInputParams = !!rawMethodParams && rawMethodParams.length > 0,
-    requireParam = !method.hasOptionalOptions;
-  if (!hasInputParams && !requireParam) {
-    return [];
-  }
-
-  const allSideAssignments = [],
-    querySideAssignments: string[] = [],
-    headerSideAssignments: string[] = [];
-  if (
-    !!requestParameter.body &&
-    requestParameter.body &&
-    requestParameter.body.body &&
-    requestParameter.body.body?.length > 0
-  ) {
-    const body = requestParameter.body.body[0];
-    if (body) {
-      const bodyTypeName = body.typeName ?? body.type;
-      if (bodyTypeName !== "string" && body.oriSchema) {
-        schemaMap.set(bodyTypeName, body.oriSchema);
-      }
-      allSideAssignments.push(
-        ` body: ` + generateParameterTypeValue(bodyTypeName, "body", schemaMap)
-      );
-    }
-  }
-
-  requestParameter.parameters
-    ?.filter((p) => p.type === "query")
-    .forEach((p) => {
-      const name = `${p.name}`;
-      querySideAssignments.push(
-        `${name}: ` + generateParameterTypeValue(p.param.type, name, schemaMap)
-      );
-    });
-
-  if (querySideAssignments.length > 0) {
-    allSideAssignments.push(
-      ` queryParameters: { ` + querySideAssignments.join(", ") + `}`
-    );
-  }
-  requestParameter.parameters
-    ?.filter((p) => p.type === "header")
-    .filter((p) => p.name.toLowerCase() !== "contenttype")
-    .forEach((p) => {
-      const name = `${p.name}`;
-      headerSideAssignments.push(
-        `${name}: ` + generateParameterTypeValue(p.param.type, name, schemaMap)
-      );
-    });
-  if (headerSideAssignments.length > 0) {
-    allSideAssignments.push(
-      ` headers: { ` + headerSideAssignments.join(", ") + `}`
-    );
-  }
-  const contentType = requestParameter.parameters
-    ?.filter((p) => p.type === "header")
-    .filter((p) => p.name.toLowerCase() === "contenttype");
-  const firstContentType = contentType?.[0];
-  if (firstContentType) {
-    allSideAssignments.push(
-      ` ${firstContentType.name}: ` +
-        generateParameterTypeValue(
-          firstContentType.param.type,
-          firstContentType.name,
-          schemaMap
-        )
-    );
-  }
-  let value: string = `{}`;
-  if (allSideAssignments.length > 0) {
-    value = `{ ` + allSideAssignments.join(", ") + `}`;
-  } else {
-    return [];
-  }
-
-  const optionParam: SampleParameter = {
-    name: "options",
-    assignment: `const options =` + value + `;`,
-    value
-  };
-  return [optionParam];
-}
-
-function addValueInImportedDict(
-  key: string,
-  val: string,
-  importedDict: Record<string, Set<string>>
-) {
-  if (!importedDict[key]) {
-    importedDict[key] = new Set<string>();
-  }
-  importedDict[key].add(val);
-}
-
-function buildMethodParamMap(model: RLCModel): Map<string, OperationParameter> {
-  const map = new Map<string, OperationParameter>();
-  (model.parameters ?? []).forEach((p) => {
-    const operatonConcante = getOperationConcate(
-      p.operationName,
-      p.operationGroup,
-      model.options?.sourceFrom
-    );
-    map.set(operatonConcante, p);
-  });
-  return map;
-}
-
-function getOperationConcate(
-  opName: string,
-  opGroup: string,
-  sourceFrom?: string
-) {
-  return sourceFrom === "Swagger"
-    ? opGroup === "" || opGroup === "Client"
-      ? opName
-      : `${opGroup}${opName}`
-    : `${opGroup}_${opName}`;
-}

package/src/transform/transformApiVersionInfo.ts

@@ -1,116 +0,0 @@
-import {
-  ApiVersionInfo,
-  ApiVersionPosition,
-  extractDefinedPosition,
-  extractPathApiVersion,
-  SchemaContext,
-  UrlInfo
-} from "../rlc-common/index.js";
-import {
-  getHttpOperationWithCache,
-  isApiVersion,
-  SdkClient
-} from "@azure-tools/typespec-client-generator-core";
-import { SdkContext } from "../utils/interfaces.js";
-import {
-  getDefaultApiVersionString,
-  getSchemaForType,
-  trimUsage
-} from "../utils/modelUtils.js";
-import { listOperationsUnderRLCClient } from "../utils/clientUtils.js";
-
-export function transformApiVersionInfo(
-  client: SdkClient,
-  dpgContext: SdkContext,
-  urlInfo?: UrlInfo
-): ApiVersionInfo | undefined {
-  const queryVersionDetail = getOperationApiVersion(client, dpgContext);
-  const pathVersionDetail = extractPathApiVersion(urlInfo);
-  const isCrossedVersion =
-    queryVersionDetail || pathVersionDetail
-      ? Boolean(
-          pathVersionDetail?.isCrossedVersion ||
-          queryVersionDetail?.isCrossedVersion
-        )
-      : undefined;
-  const defaultValue =
-    (pathVersionDetail || queryVersionDetail) && !isCrossedVersion
-      ? (getDefaultApiVersionString(dpgContext) ??
-        pathVersionDetail?.defaultValue ??
-        queryVersionDetail?.defaultValue)
-      : undefined;
-
-  if (pathVersionDetail && queryVersionDetail) {
-    return pathVersionDetail;
-  }
-  if (pathVersionDetail && !queryVersionDetail) {
-    dpgContext.hasApiVersionInClient = true;
-  }
-  return {
-    definedPosition: extractDefinedPosition(
-      queryVersionDetail,
-      pathVersionDetail
-    ),
-    isCrossedVersion,
-    defaultValue,
-    required: pathVersionDetail?.required ?? queryVersionDetail?.required
-  };
-}
-
-export function getOperationApiVersion(
-  client: SdkClient,
-  dpgContext: SdkContext
-): ApiVersionInfo | undefined {
-  const apiVersionTypes = new Set<string>();
-  const locations = new Set<ApiVersionPosition>();
-  const required = new Set<boolean>();
-  dpgContext.hasApiVersionInClient = true;
-  let hasApiVersionInOperation = true;
-  for (const op of listOperationsUnderRLCClient(client)) {
-    hasApiVersionInOperation = false;
-    const route = getHttpOperationWithCache(dpgContext, op);
-    // ignore overload base operation
-    if (route.overloads && route.overloads?.length > 0) {
-      continue;
-    }
-    const params = route.parameters.parameters.filter(
-      (p) =>
-        (p.type === "query" || p.type === "path") &&
-        isApiVersion(dpgContext, p.param)
-    );
-    params.map((p) => {
-      const type = getSchemaForType(dpgContext, p.param.type, {
-        usage: [SchemaContext.Exception, SchemaContext.Input],
-        needRef: false,
-        relevantProperty: p.param
-      });
-      required.add(!p.param.optional);
-      if (p.type === "query" || p.type === "path") {
-        locations.add(p.type);
-      }
-      const typeString = JSON.stringify(trimUsage(type));
-      apiVersionTypes.add(typeString);
-    });
-    if (apiVersionTypes.size > 1 || !dpgContext.hasApiVersionInClient) {
-      break;
-    }
-    if (params.length === 1) {
-      hasApiVersionInOperation = true;
-    }
-    if (!hasApiVersionInOperation) {
-      dpgContext.hasApiVersionInClient = false;
-    }
-  }
-  // If no api-version parameter defined return directly
-  if (apiVersionTypes.size === 0 || !dpgContext.hasApiVersionInClient) {
-    return;
-  }
-  const detail: ApiVersionInfo = {
-    definedPosition:
-      locations.size > 1 ? "duplicate" : locations.values().next().value,
-    isCrossedVersion: apiVersionTypes.size > 1,
-    defaultValue: undefined, // We won't prompt the query versions into client one
-    required: required.values().next().value
-  };
-  return detail;
-}