@azure-tools/typespec-ts 0.36.0 → 0.37.0-alpha.20241230.1

package/src/modular/buildClassicalOperationGroups.ts

@@ -2,63 +2,68 @@ import { NameType } from "@azure-tools/rlc-common";
 import { SourceFile } from "ts-morph";
 import { getClassicalOperation } from "./helpers/classicalOperationHelpers.js";
 import { getClassicalLayerPrefix } from "./helpers/namingHelpers.js";
-import {
-  Client,
-  ModularCodeModel,
-  OperationGroup
-} from "./modularCodeModel.js";
+import { ModularEmitterOptions } from "./interfaces.js";
 import { SdkContext } from "../utils/interfaces.js";
+import { getMethodHierarchiesMap } from "../utils/operationUtil.js";
+import {
+  SdkClientType,
+  SdkServiceOperation
+} from "@azure-tools/typespec-client-generator-core";
+import { getModularClientOptions } from "../utils/clientUtils.js";
 
 export function buildClassicOperationFiles(
   dpgContext: SdkContext,
-  codeModel: ModularCodeModel,
-  client: Client
+  client: SdkClientType<SdkServiceOperation>,
+  emitterOptions: ModularEmitterOptions
 ) {
+  // const sdkPackage = dpgContext.sdkPackage;
+  const { subfolder } = getModularClientOptions(dpgContext, client);
   const classicOperationFiles: Map<string, SourceFile> = new Map<
     string,
     SourceFile
   >();
-  for (const operationGroup of client.operationGroups) {
-    if (operationGroup.namespaceHierarchies.length > 0) {
+  const methodMap = getMethodHierarchiesMap(dpgContext, client);
+  for (const [prefixKey, operations] of methodMap) {
+    const prefixes = prefixKey.split("/");
+    if (prefixes.length > 0 && prefixKey !== "") {
       const classicOperationFileName =
-        operationGroup.namespaceHierarchies.length > 0
+        prefixes.length > 0
           ? `${getClassicalLayerPrefix(
-              operationGroup,
+              prefixes,
               NameType.File,
               "/",
-              operationGroup.namespaceHierarchies.length - 1
+              prefixes.length - 1
             )}/index`
           : // When the program has no operation groups defined all operations are put
             // into a nameless operation group. We'll call this operations.
             "index";
 
-      const subfolder = client.subfolder;
-      const srcPath = codeModel.modularOptions.sourceRoot;
+      const srcPath = emitterOptions.modularOptions.sourceRoot;
       const classicFile =
         classicOperationFiles.get(classicOperationFileName) ??
-        codeModel.project.createSourceFile(
+        emitterOptions.project.createSourceFile(
           `${srcPath}/${
             subfolder && subfolder !== "" ? subfolder + "/" : ""
           }classic/${classicOperationFileName}.ts`
         );
-      getClassicalOperation(dpgContext, client, classicFile, operationGroup);
+      getClassicalOperation(dpgContext, client, classicFile, [
+        prefixes,
+        operations
+      ]);
 
-      importApis(classicFile, client, codeModel, operationGroup);
+      importApis(dpgContext, classicFile, client, emitterOptions, prefixes);
       // We need to import the paging helpers and types explicitly because ts-morph may not be able to find them.
       classicOperationFiles.set(classicOperationFileName, classicFile);
     }
   }
-  for (const operationGroup of client.operationGroups) {
-    if (operationGroup.namespaceHierarchies.length > 0) {
-      for (
-        let layer = 0;
-        layer < operationGroup.namespaceHierarchies.length - 1;
-        layer++
-      ) {
+  for (const [prefixKey, operations] of methodMap) {
+    const prefixes = prefixKey.split("/");
+    if (prefixes.length > 0 && prefixKey !== "") {
+      for (let layer = 0; layer < prefixes.length - 1; layer++) {
         const classicOperationFileName =
-          operationGroup.namespaceHierarchies.length > 0
+          prefixes.length > 0
             ? `${getClassicalLayerPrefix(
-                operationGroup,
+                prefixes,
                 NameType.File,
                 "/",
                 layer
@@ -66,12 +71,10 @@ export function buildClassicOperationFiles(
             : // When the program has no operation groups defined all operations are put
               // into a nameless operation group. We'll call this operations.
               "index";
-
-        const subfolder = client.subfolder;
-        const srcPath = codeModel.modularOptions.sourceRoot;
+        const srcPath = emitterOptions.modularOptions.sourceRoot;
         const classicFile =
           classicOperationFiles.get(classicOperationFileName) ??
-          codeModel.project.createSourceFile(
+          emitterOptions.project.createSourceFile(
             `${srcPath}/${
               subfolder && subfolder !== "" ? subfolder + "/" : ""
             }classic/${classicOperationFileName}.ts`
@@ -80,10 +83,17 @@ export function buildClassicOperationFiles(
           dpgContext,
           client,
           classicFile,
-          operationGroup,
+          [prefixes, operations],
+          layer
+        );
+        importApis(
+          dpgContext,
+          classicFile,
+          client,
+          emitterOptions,
+          prefixes,
           layer
         );
-        importApis(classicFile, client, codeModel, operationGroup, layer);
         classicOperationFiles.set(classicOperationFileName, classicFile);
       }
     }
@@ -92,27 +102,23 @@ export function buildClassicOperationFiles(
 }
 
 function importApis(
+  context: SdkContext,
   classicFile: SourceFile,
-  client: Client,
-  modularCodeModel: ModularCodeModel,
-  operationGroup: OperationGroup,
-  layer: number = operationGroup.namespaceHierarchies.length - 1
+  client: SdkClientType<SdkServiceOperation>,
+  emitterOptions: ModularEmitterOptions,
+  prefixes: string[],
+  layer: number = prefixes.length - 1
 ) {
+  const { subfolder } = getModularClientOptions(context, client);
   const classicOperationFileName =
-    operationGroup.namespaceHierarchies.length > 0
-      ? `${getClassicalLayerPrefix(
-          operationGroup,
-          NameType.File,
-          "/",
-          layer
-        )}/index`
+    prefixes.length > 0 && prefixes[0] !== ""
+      ? `${getClassicalLayerPrefix(prefixes, NameType.File, "/", layer)}/index`
       : // When the program has no operation groups defined all operations are put
         // into a nameless operation group. We'll call this operations.
         "index";
 
-  const subfolder = client.subfolder;
-  const srcPath = modularCodeModel.modularOptions.sourceRoot;
-  const apiFile = modularCodeModel.project.getSourceFile(
+  const srcPath = emitterOptions.modularOptions.sourceRoot;
+  const apiFile = emitterOptions.project.getSourceFile(
     `${srcPath}/${
       subfolder && subfolder !== "" ? subfolder + "/" : ""
     }api/${classicOperationFileName}.ts`
@@ -134,7 +140,7 @@ function importApis(
   if (exported.length > 0 && !existApiImport) {
     classicFile.addImportDeclaration({
       moduleSpecifier: `${"../".repeat(
-        operationGroup.namespaceHierarchies.length + 1
+        prefixes.length + 1
       )}api/${classicOperationFileName}.js`,
       namedImports: exported
     });

package/src/modular/buildClientContext.ts

@@ -1,4 +1,4 @@
-import { Client, ModularCodeModel } from "./modularCodeModel.js";
+import { ModularEmitterOptions } from "./interfaces.js";
 import {
   NameType,
   isAzurePackage,
@@ -22,20 +22,24 @@ import { resolveReference } from "../framework/reference.js";
 import { useDependencies } from "../framework/hooks/useDependencies.js";
 import { buildEnumTypes, getApiVersionEnum } from "./emitModels.js";
 import {
+  SdkClientType,
   SdkHttpParameter,
-  SdkParameter
+  SdkParameter,
+  SdkServiceOperation
 } from "@azure-tools/typespec-client-generator-core";
+import { getModularClientOptions } from "../utils/clientUtils.js";
 
 /**
  * This function gets the path of the file containing the modular client context
  */
 export function getClientContextPath(
-  _client: Client,
-  codeModel: ModularCodeModel
+  context: SdkContext,
+  client: SdkClientType<SdkServiceOperation>,
+  emitterOptions: ModularEmitterOptions
 ): string {
-  const { subfolder, tcgcClient: client } = _client;
+  const { subfolder } = getModularClientOptions(context, client);
   const name = getClientName(client);
-  const srcPath = codeModel.modularOptions.sourceRoot;
+  const srcPath = emitterOptions.modularOptions.sourceRoot;
   const contentPath = `${srcPath}/${
     subfolder && subfolder !== "" ? subfolder + "/" : ""
   }api/${normalizeName(name, NameType.File)}Context.ts`;
@@ -46,39 +50,60 @@ export function getClientContextPath(
  * This function creates the file containing the modular client context
  */
 export function buildClientContext(
-  _client: Client,
   dpgContext: SdkContext,
-  codeModel: ModularCodeModel
+  client: SdkClientType<SdkServiceOperation>,
+  emitterOptions: ModularEmitterOptions
 ): SourceFile {
-  const { description, tcgcClient: client } = _client;
   const dependencies = useDependencies();
   const name = getClientName(client);
-  const requiredParams = getClientParametersDeclaration(_client, dpgContext, {
+  const { rlcClientName } = getModularClientOptions(dpgContext, client);
+  const requiredParams = getClientParametersDeclaration(client, dpgContext, {
     onClientOnly: false,
-    requiredOnly: true
+    requiredOnly: true,
+    apiVersionAsRequired: true
   });
-  const clientContextFile = codeModel.project.createSourceFile(
-    getClientContextPath(_client, codeModel)
+  const clientContextFile = emitterOptions.project.createSourceFile(
+    getClientContextPath(dpgContext, client, emitterOptions)
   );
 
   clientContextFile.addInterface({
     isExported: true,
-    name: `${_client.rlcClientName}`,
+    name: `${rlcClientName}`,
     extends: [resolveReference(dependencies.Client)],
-    docs: getDocsFromDescription(description)
+    docs: getDocsFromDescription(client.doc),
+    properties: getClientParameters(client, dpgContext, {
+      onClientOnly: false,
+      requiredOnly: true,
+      apiVersionAsRequired: true
+    })
+      .filter((p) => {
+        const clientParamName = getClientParameterName(p);
+        return (
+          clientParamName !== "endpointParam" &&
+          clientParamName !== "credential"
+        );
+      })
+      .map((p) => {
+        return {
+          name: getClientParameterName(p),
+          type: getTypeExpression(dpgContext, p.type),
+          hasQuestionToken: false,
+          docs: getDocsWithKnownVersion(dpgContext, p)
+        };
+      })
   });
 
   clientContextFile.addInterface({
     name: `${name}ClientOptionalParams`,
     isExported: true,
     extends: [resolveReference(dependencies.ClientOptions)],
-    properties: getClientParameters(_client, dpgContext, {
+    properties: getClientParameters(client, dpgContext, {
       optionalOnly: true
     })
       .filter((p) => p.name !== "endpoint")
       .map((p) => {
         return {
-          name: normalizeName(p.name, NameType.Parameter),
+          name: getClientParameterName(p),
           type:
             p.name.toLowerCase() === "apiversion"
               ? "string"
@@ -92,31 +117,36 @@ export function buildClientContext(
 
   // TODO use binder here
   // (for now) now logger for unbranded pkgs
-  if (isAzurePackage(codeModel)) {
+  if (isAzurePackage(emitterOptions)) {
     clientContextFile.addImportDeclaration({
       moduleSpecifier:
-        codeModel.clients.length > 1 ? "../../logger.js" : "../logger.js",
+        dpgContext.sdkPackage.clients.length > 1
+          ? "../../logger.js"
+          : "../logger.js",
       namedImports: ["logger"]
     });
   }
 
   const factoryFunction = clientContextFile.addFunction({
-    docs: getDocsFromDescription(description),
+    docs: getDocsFromDescription(client.doc),
     name: `create${name}`,
-    returnType: `${_client.rlcClientName}`,
-    parameters: requiredParams,
+    returnType: `${rlcClientName}`,
+    parameters: getClientParametersDeclaration(client, dpgContext, {
+      onClientOnly: false,
+      requiredOnly: true
+    }),
     isExported: true
   });
 
   const endpointParam = buildGetClientEndpointParam(
     factoryFunction,
     dpgContext,
-    _client
+    client
   );
-  const credentialParam = buildGetClientCredentialParam(_client, codeModel);
+  const credentialParam = buildGetClientCredentialParam(client, emitterOptions);
   const optionsParam = buildGetClientOptionsParam(
     factoryFunction,
-    codeModel,
+    emitterOptions,
     endpointParam
   );
 
@@ -127,7 +157,7 @@ export function buildClientContext(
   );
 
   const { customHttpAuthHeaderName, customHttpAuthSharedKeyPrefix } =
-    codeModel.options;
+    emitterOptions.options;
 
   if (customHttpAuthHeaderName && customHttpAuthSharedKeyPrefix) {
     factoryFunction.addStatements(`
@@ -144,17 +174,28 @@ export function buildClientContext(
   }
 
   let apiVersionPolicyStatement = `clientContext.pipeline.removePolicy({ name: "ApiVersionPolicy" });`;
+  const apiVersionParam = getClientParameters(client, dpgContext).find(
+    (x) => x.isApiVersionParam
+  );
+  const endpointParameter = getClientParameters(client, dpgContext, {
+    onClientOnly: false,
+    requiredOnly: true,
+    skipEndpointTemplate: true
+  }).find((x) => x.kind === "endpoint");
+  if (apiVersionParam) {
+    const templateArguments =
+      endpointParameter && endpointParameter.type.kind === "endpoint"
+        ? endpointParameter.type.templateArguments
+        : endpointParameter && endpointParameter.type.kind === "union"
+          ? endpointParameter.type.variantTypes[0]?.templateArguments
+          : [];
+    const apiVersionInEndpoint =
+      templateArguments && templateArguments.find((p) => p.isApiVersionParam);
+    if (!apiVersionInEndpoint && apiVersionParam.clientDefaultValue) {
+      apiVersionPolicyStatement += `const apiVersion = options.apiVersion ?? "${apiVersionParam.clientDefaultValue}";`;
+    }
 
-  if (dpgContext.hasApiVersionInClient) {
-    const apiVersionParam = getClientParameters(_client, dpgContext).find(
-      (x) => x.isApiVersionParam && x.kind === "method"
-    );
-
-    if (apiVersionParam) {
-      if (apiVersionParam.clientDefaultValue) {
-        apiVersionPolicyStatement += `const apiVersion = options.apiVersion ?? "${apiVersionParam.clientDefaultValue}";`;
-      }
-
+    if (apiVersionParam.kind === "method") {
       apiVersionPolicyStatement += `
       clientContext.pipeline.addPolicy({
         name: 'ClientApiVersionPolicy',
@@ -172,20 +213,36 @@ export function buildClientContext(
         },
       });`;
     }
-  } else if (isAzurePackage(codeModel)) {
+  } else if (isAzurePackage(emitterOptions)) {
     apiVersionPolicyStatement += `
-      if (options.apiVersion) {
-        logger.warning("This client does not support client api-version, please change it at the operation level");
-      }`;
+        if (options.apiVersion) {
+          logger.warning("This client does not support client api-version, please change it at the operation level");
+        }`;
   } else {
     apiVersionPolicyStatement += `
-      if (options.apiVersion) {
-        console.warn("This client does not support client api-version, please change it at the operation level");
-      }`;
+        if (options.apiVersion) {
+          console.warn("This client does not support client api-version, please change it at the operation level");
+        }`;
   }
   factoryFunction.addStatements(apiVersionPolicyStatement);
 
-  factoryFunction.addStatements("return clientContext;");
+  const contextRequiredParam = requiredParams.filter(
+    (p) =>
+      p.name !== "endpointParam" &&
+      p.name !== "credential" &&
+      p.name !== "options"
+  );
+  if (contextRequiredParam.length) {
+    factoryFunction.addStatements(
+      `return { ...clientContext, ${contextRequiredParam
+        .map((p) => {
+          return p.name;
+        })
+        .join(", ")}} as ${rlcClientName};`
+    );
+  } else {
+    factoryFunction.addStatements(`return clientContext;`);
+  }
 
   clientContextFile.fixMissingImports(
     {},

package/src/modular/buildModularOptions.ts

@@ -0,0 +1,27 @@
+import { ModularEmitterOptions } from "./interfaces.js";
+
+import { Project } from "ts-morph";
+import { SdkContext } from "../utils/interfaces.js";
+
+let CASING: "camel" | "snake" = "snake";
+
+export function transformModularEmitterOptions(
+  dpgContext: SdkContext,
+  modularSourcesRoot: string,
+  project: Project,
+  options: { casing: "snake" | "camel" } = { casing: "snake" }
+): ModularEmitterOptions {
+  CASING = options.casing ?? CASING;
+  const emitterOptions: ModularEmitterOptions = {
+    options: dpgContext.rlcOptions ?? {},
+    modularOptions: {
+      sourceRoot: modularSourcesRoot,
+      compatibilityMode: !!dpgContext.rlcOptions?.compatibilityMode,
+      experimentalExtensibleEnums:
+        !!dpgContext.rlcOptions?.experimentalExtensibleEnums
+    },
+    project
+  };
+
+  return emitterOptions;
+}