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

package/src/modular/buildSubpathIndex.ts

@@ -1,6 +1,12 @@
-import { Client, ModularCodeModel } from "./modularCodeModel.js";
+import {
+  SdkClientType,
+  SdkServiceOperation
+} from "@azure-tools/typespec-client-generator-core";
+import { ModularEmitterOptions } from "./interfaces.js";
 
 import { join } from "path";
+import { SdkContext } from "../utils/interfaces.js";
+import { getModularClientOptions } from "../utils/clientUtils.js";
 
 export interface buildSubpathIndexFileOptions {
   exportIndex?: boolean;
@@ -8,17 +14,20 @@ export interface buildSubpathIndexFileOptions {
 }
 
 export function buildSubpathIndexFile(
-  codeModel: ModularCodeModel,
+  context: SdkContext,
+  emitterOptions: ModularEmitterOptions,
   subpath: string,
-  client?: Client,
+  client?: SdkClientType<SdkServiceOperation>,
   options: buildSubpathIndexFileOptions = {}
 ) {
-  const subfolder = client?.subfolder ?? "";
-  const srcPath = codeModel.modularOptions.sourceRoot;
+  const subfolder = client
+    ? (getModularClientOptions(context, client).subfolder ?? "")
+    : "";
+  const srcPath = emitterOptions.modularOptions.sourceRoot;
   // Skip to export these files because they are used internally.
   const skipFiles = ["pagingHelpers.ts", "pollingHelpers.ts"];
   const apiFilePattern = join(srcPath, subfolder, subpath);
-  const apiFiles = codeModel.project.getSourceFiles().filter((file) => {
+  const apiFiles = emitterOptions.project.getSourceFiles().filter((file) => {
     return file
       .getFilePath()
       .replace(/\\/g, "/")
@@ -27,7 +36,7 @@ export function buildSubpathIndexFile(
   if (apiFiles.length === 0) {
     return;
   }
-  const indexFile = codeModel.project.createSourceFile(
+  const indexFile = emitterOptions.project.createSourceFile(
     `${srcPath}/${subfolder}/${subpath}/index.ts`
   );
   for (const file of apiFiles) {

package/src/modular/emitLoggerFile.ts

@@ -1,18 +1,20 @@
-import { Project } from "ts-morph";
-import { ModularCodeModel } from "./modularCodeModel.js";
+import { ModularEmitterOptions } from "./interfaces.js";
 
 export function emitLoggerFile(
-  codeModel: ModularCodeModel,
-  project: Project,
+  emitterOptions: ModularEmitterOptions,
   srcPath: string = "src"
 ) {
-  if (codeModel.options.flavor !== "azure") {
+  if (emitterOptions.options.flavor !== "azure") {
     return;
   }
 
-  const sourceFile = project.createSourceFile(`${srcPath}/logger.ts`, "", {
-    overwrite: true
-  });
+  const sourceFile = emitterOptions.project.createSourceFile(
+    `${srcPath}/logger.ts`,
+    "",
+    {
+      overwrite: true
+    }
+  );
 
   sourceFile.addImportDeclaration({
     namedImports: ["createClientLogger"],
@@ -20,8 +22,8 @@ export function emitLoggerFile(
   });
 
   const name =
-    codeModel.options.packageDetails?.nameWithoutScope ??
-    codeModel.options.packageDetails?.name;
+    emitterOptions.options.packageDetails?.nameWithoutScope ??
+    emitterOptions.options.packageDetails?.name;
   sourceFile.addStatements(
     `export const logger = createClientLogger("${name}");`
   );

package/src/modular/emitModels.ts

@@ -22,6 +22,7 @@ import {
   SdkModelType,
   SdkNullableType,
   SdkServiceMethod,
+  SdkServiceOperation,
   SdkType,
   SdkUnionType,
   UsageFlags,
@@ -346,7 +347,7 @@ function emitEnumMember(member: SdkEnumValueType): EnumMemberStructure {
   return memberStructure;
 }
 
-export function buildModelInterface(
+function buildModelInterface(
   context: SdkContext,
   type: SdkModelType
 ): InterfaceDeclarationStructure {
@@ -408,6 +409,13 @@ function addExtendedDictInfo(
     }
     modelInterface.extends.push(`Record<string, any>`);
   } else {
+    reportDiagnostic(context.program, {
+      code: "compatible-additional-properties",
+      format: {
+        modelName: modelInterface?.name ?? ""
+      },
+      target: NoTarget
+    });
     modelInterface.properties?.push({
       name: "additionalProperties",
       docs: ["Additional properties"],
@@ -557,7 +565,7 @@ export function visitPackageTypes(context: SdkContext) {
 
 function visitClient(
   context: SdkContext,
-  client: SdkClientType<SdkHttpOperation>
+  client: SdkClientType<SdkServiceOperation>
 ) {
   // Comment this out for now, as client initialization is not used in the generated code
   // visitType(client.initialization, emitQueue);
@@ -634,32 +642,32 @@ function visitType(context: SdkContext, type: SdkType | undefined) {
       visitType(context, type.additionalProperties);
     }
     for (const property of type.properties) {
-      if (!emitQueue.has(property.type as any)) {
+      if (!emitQueue.has(property.type)) {
         visitType(context, property.type);
       }
     }
     if (type.discriminatedSubtypes) {
       for (const subType of Object.values(type.discriminatedSubtypes)) {
-        if (!emitQueue.has(subType as any)) {
+        if (!emitQueue.has(subType)) {
           visitType(context, subType);
         }
       }
     }
   }
   if (type.kind === "array") {
-    if (!emitQueue.has(type.valueType as any)) {
+    if (!emitQueue.has(type.valueType)) {
       visitType(context, type.valueType);
     }
   }
   if (type.kind === "dict") {
-    if (!emitQueue.has(type.valueType as any)) {
+    if (!emitQueue.has(type.valueType)) {
       visitType(context, type.valueType);
     }
   }
   if (type.kind === "union") {
     emitQueue.add(type);
     for (const value of type.variantTypes) {
-      if (!emitQueue.has(value as any)) {
+      if (!emitQueue.has(value)) {
         visitType(context, value);
       }
     }

package/src/modular/emitModelsOptions.ts

@@ -1,128 +1,28 @@
 import * as path from "path";
 
-import {
-  Client,
-  ModularCodeModel,
-  Type as ModularType
-} from "./modularCodeModel.js";
-import { InterfaceDeclarationStructure, OptionalKind } from "ts-morph";
+import { ModularEmitterOptions } from "./interfaces.js";
 
 import { buildOperationOptions } from "./buildOperations.js";
-import { getDocsFromDescription } from "./helpers/docsHelpers.js";
-import { getImportSpecifier } from "@azure-tools/rlc-common";
-import { getType } from "./helpers/typeHelpers.js";
 import { SdkContext } from "../utils/interfaces.js";
+import {
+  SdkClientType,
+  SdkServiceOperation
+} from "@azure-tools/typespec-client-generator-core";
+import { getMethodHierarchiesMap } from "../utils/operationUtil.js";
+import { getModularClientOptions } from "../utils/clientUtils.js";
 
 // ====== UTILITIES ======
 
-function isAzureCoreErrorSdkType(t: ModularType) {
-  return (
-    t.name &&
-    ["error", "errormodel", "innererror", "errorresponse"].includes(
-      t.name.toLowerCase()
-    ) &&
-    t.coreTypeInfo === "ErrorType"
-  );
-}
-
-function isAzureCoreLroSdkType(t: ModularType) {
-  return (
-    t.name &&
-    ["operationstate"].includes(t.name.toLowerCase()) &&
-    t.coreTypeInfo === "LroType"
-  );
-}
-
-export function isModelWithAdditionalProperties(t: ModularType) {
-  return t.type === "dict" && t.name !== "Record";
-}
-
-function getCoreClientErrorType(name: string, coreClientTypes: Set<string>) {
-  const coreClientType: string = name === "Error" ? "ErrorModel" : name;
-  coreClientTypes.add(coreClientType);
-  return coreClientType;
-}
-
-function getCoreLroType(name: string, coreLroTypes: Set<string>) {
-  const coreLroType = name === "OperationState" ? "CoreOperationStatus" : name;
-  coreLroTypes.add(coreLroType);
-  return coreLroType;
-}
-
-/**
- * Extracts all the aliases from the code model
- * 1. alias from polymorphic base model, where we need to use typescript union to combine all the sub models
- * 2. alias from unions, where we also need to use typescript union to combine all the union variants
- */
-export function extractAliases(codeModel: ModularCodeModel): ModularType[] {
-  const models = codeModel.types.filter(
-    (t) =>
-      ((t.type === "model" || t.type === "combined") &&
-        t.alias &&
-        t.aliasType) ||
-      (isModelWithAdditionalProperties(t) && t.alias && t.aliasType)
-  );
-  return models;
-}
-
-type InterfaceStructure = OptionalKind<InterfaceDeclarationStructure> & {
-  extends: string[];
-};
-
-export function buildModelInterface(
-  model: ModularType,
-  cache: { coreClientTypes: Set<string>; coreLroTypes: Set<string> }
-): InterfaceStructure {
-  const modelProperties = model.properties ?? [];
-  const modelInterface = {
-    name: model.alias ?? model.name ?? "FIXMYNAME",
-    isExported: true,
-    docs: getDocsFromDescription(model.description),
-    extends: [] as string[],
-    properties: (modelProperties ?? []).map((p) => {
-      const propertyMetadata = getType(p.type, p.format);
-      let propertyTypeName = propertyMetadata.name;
-      if (isAzureCoreErrorSdkType(p.type)) {
-        propertyTypeName = getCoreClientErrorType(
-          propertyTypeName,
-          cache.coreClientTypes
-        );
-      }
-      if (isAzureCoreLroSdkType(p.type)) {
-        propertyTypeName = getCoreLroType(propertyTypeName, cache.coreLroTypes);
-      }
-
-      return {
-        name: `"${p.clientName}"`,
-        docs: getDocsFromDescription(p.description),
-        hasQuestionToken: p.optional,
-        isReadonly: p.readonly,
-        type: propertyTypeName
-      };
-    })
-  };
-
-  return modelInterface;
-}
-
-export function buildModelTypeAlias(model: ModularType) {
-  return {
-    name: model.name!,
-    isExported: true,
-    docs: ["Alias for " + model.name],
-    type: model.aliasType!
-  };
-}
-
 export function buildApiOptions(
   context: SdkContext,
-  client: Client,
-  codeModel: ModularCodeModel
+  client: SdkClientType<SdkServiceOperation>,
+  emitterOptions: ModularEmitterOptions
 ) {
-  const modelOptionsFile = codeModel.project.createSourceFile(
+  const { subfolder } = getModularClientOptions(context, client);
+  const modelOptionsFile = emitterOptions.project.createSourceFile(
     path.join(
-      codeModel.modularOptions.sourceRoot,
-      client.subfolder ?? "",
+      emitterOptions.modularOptions.sourceRoot,
+      subfolder ?? "",
       `api/options.ts`
     ),
     undefined,
@@ -130,20 +30,13 @@ export function buildApiOptions(
       overwrite: true
     }
   );
-  for (const operationGroup of client.operationGroups) {
-    operationGroup.operations.forEach((o) => {
-      buildOperationOptions(context, o, modelOptionsFile);
+  const methodMap = getMethodHierarchiesMap(context, client);
+  for (const [prefixKey, operations] of methodMap) {
+    const prefixes = prefixKey.split("/");
+    operations.forEach((o) => {
+      buildOperationOptions(context, [prefixes, o], modelOptionsFile);
     });
   }
-  modelOptionsFile.addImportDeclarations([
-    {
-      moduleSpecifier: getImportSpecifier(
-        "restClient",
-        codeModel.runtimeImports
-      ),
-      namedImports: ["OperationOptions"]
-    }
-  ]);
 
   modelOptionsFile
     .getImportDeclarations()

package/src/modular/emitSamples.ts

@@ -243,9 +243,8 @@ function buildParameterValueMap(example: SdkHttpOperationExample) {
   const parameterMap: Record<string, SdkHttpParameterExampleValue> = {};
   example.parameters.forEach(
     (param) =>
-      (parameterMap[
-        (param.parameter as any).serializedName ?? param.parameter.name
-      ] = param)
+      (parameterMap[param.parameter.serializedName ?? param.parameter.name] =
+        param)
   );
   return parameterMap;
 }

package/src/modular/helpers/classicalOperationHelpers.ts

@@ -6,50 +6,42 @@ import {
   SourceFile,
   StructureKind
 } from "ts-morph";
-import { Client, OperationGroup } from "../modularCodeModel.js";
-import { getClassicalLayerPrefix, getClientName } from "./namingHelpers.js";
+import { getClassicalLayerPrefix } from "./namingHelpers.js";
 import { getOperationFunction } from "./operationHelpers.js";
 import { SdkContext } from "../../utils/interfaces.js";
+import {
+  SdkClientType,
+  SdkServiceOperation
+} from "@azure-tools/typespec-client-generator-core";
+import { getModularClientOptions } from "../../utils/clientUtils.js";
+import { ServiceOperation } from "../../utils/operationUtil.js";
 
-export function shouldPromoteSubscriptionId(
-  dpgContext: SdkContext,
-  operationGroup: OperationGroup
-) {
-  const hasSubscriptionIdParameter = operationGroup.operations.some((op) =>
-    op.parameters.some((p) => p.clientName === "subscriptionId")
-  );
-  return dpgContext?.rlcOptions?.azureArm && hasSubscriptionIdParameter;
-}
 export function getClassicalOperation(
   dpgContext: SdkContext,
-  client: Client,
+  client: SdkClientType<SdkServiceOperation>,
   classicFile: SourceFile,
-  operationGroup: OperationGroup,
-  layer: number = operationGroup.namespaceHierarchies.length - 1
+  operationGroup: [string[], ServiceOperation[]],
+  layer: number = operationGroup[0].length - 1
 ) {
-  // TODO: remove this logic once client-level parameter design is finalized
-  // https://github.com/Azure/autorest.typescript/issues/2618
-  const hasSubscriptionIdPromoted = shouldPromoteSubscriptionId(
-    dpgContext,
-    operationGroup
-  );
-  const modularClientName = `${getClientName(client.tcgcClient)}Context`;
+  const prefixes = operationGroup[0];
+  const operations = operationGroup[1];
+  const { rlcClientName } = getModularClientOptions(dpgContext, client);
   const hasClientContextImport = classicFile
     .getImportDeclarations()
     .filter((i) => {
       return (
         i.getModuleSpecifierValue() ===
         `${"../".repeat(layer + 2)}api/${normalizeName(
-          modularClientName,
+          rlcClientName,
           NameType.File
         )}.js`
       );
     });
   if (!hasClientContextImport || hasClientContextImport.length === 0) {
     classicFile.addImportDeclaration({
-      namedImports: [client.rlcClientName],
+      namedImports: [rlcClientName],
       moduleSpecifier: `${"../".repeat(layer + 2)}api/${normalizeName(
-        modularClientName,
+        rlcClientName,
         NameType.File
       )}.js`
     });
@@ -60,18 +52,18 @@ export function getClassicalOperation(
     string | undefined
   >();
   const operationDeclarations: OptionalKind<FunctionDeclarationStructure>[] =
-    operationGroup.operations.map((operation) => {
+    operations.map((operation) => {
       const declarations = getOperationFunction(
         dpgContext,
-        operation,
-        modularClientName
+        [prefixes, operation],
+        rlcClientName
       );
       operationMap.set(declarations, operation.oriName);
       return declarations;
     });
 
   const interfaceNamePrefix = getClassicalLayerPrefix(
-    operationGroup,
+    prefixes,
     NameType.Interface,
     "",
     layer
@@ -81,18 +73,17 @@ export function getClassicalOperation(
     .getInterfaces()
     .filter((i) => i.getName() === interfaceName)[0];
   const properties: OptionalKind<PropertySignatureStructure>[] = [];
-  if (layer !== operationGroup.namespaceHierarchies.length - 1) {
+  if (layer !== prefixes.length - 1) {
     properties.push({
       kind: StructureKind.PropertySignature,
-      name:
-        normalizeName(
-          (layer === operationGroup.namespaceHierarchies.length - 1
-            ? operationGroup.namespaceHierarchies[layer]
-            : operationGroup.namespaceHierarchies[layer + 1]) ?? "",
-          NameType.Property
-        ) ?? operationGroup.propertyName,
+      name: normalizeName(
+        (layer === prefixes.length - 1
+          ? prefixes[layer]
+          : prefixes[layer + 1]) ?? "",
+        NameType.Property
+      ),
       type: `${getClassicalLayerPrefix(
-        operationGroup,
+        prefixes,
         NameType.Interface,
         "",
         layer + 1
@@ -105,9 +96,6 @@ export function getClassicalOperation(
         name: getClassicalMethodName(d),
         type: `(${d.parameters
           ?.filter((p) => p.name !== "context")
-          ?.filter(
-            (p) => !(hasSubscriptionIdPromoted && p.name === "subscriptionId")
-          )
           .map(
             (p) =>
               p.name +
@@ -134,10 +122,10 @@ export function getClassicalOperation(
     });
   }
 
-  if (layer === operationGroup.namespaceHierarchies.length - 1) {
+  if (layer === prefixes.length - 1) {
     classicFile.addFunction({
       name: `get${getClassicalLayerPrefix(
-        operationGroup,
+        prefixes,
         NameType.Interface,
         "",
         layer
@@ -146,21 +134,14 @@ export function getClassicalOperation(
       parameters: [
         {
           name: "context",
-          type: client.rlcClientName
-        },
-        ...(hasSubscriptionIdPromoted
-          ? [{ name: "subscriptionId", type: "string" }]
-          : [])
+          type: rlcClientName
+        }
       ],
       statements: `return {
         ${operationDeclarations
           .map((d) => {
             return `${getClassicalMethodName(d)}: (${d.parameters
               ?.filter((p) => p.name !== "context")
-              ?.filter(
-                (p) =>
-                  !(hasSubscriptionIdPromoted && p.name === "subscriptionId")
-              )
               .map(
                 (p) =>
                   p.name +
@@ -184,7 +165,7 @@ export function getClassicalOperation(
   }
 
   const operationFunctionName = `get${getClassicalLayerPrefix(
-    operationGroup,
+    prefixes,
     NameType.Interface,
     "",
     layer
@@ -197,57 +178,50 @@ export function getClassicalOperation(
     if (returnStatement) {
       let statement = `,
       ...get${getClassicalLayerPrefix(
-        operationGroup,
+        prefixes,
         NameType.Interface,
         "",
         layer + 1
-      )}Operations(context${
-        hasSubscriptionIdPromoted ? ", subscriptionId" : ""
-      })}`;
-      if (layer !== operationGroup.namespaceHierarchies.length - 1) {
+      )}Operations(context)}`;
+      if (layer !== prefixes.length - 1) {
         statement = `,
         ${normalizeName(
-          operationGroup.namespaceHierarchies[layer + 1] ?? "FIXME",
+          prefixes[layer + 1] ?? "FIXME",
           NameType.Property
         )}: get${getClassicalLayerPrefix(
-          operationGroup,
+          prefixes,
           NameType.Interface,
           "",
           layer + 1
-        )}Operations(context${
-          hasSubscriptionIdPromoted ? ", subscriptionId" : ""
-        })}`;
+        )}Operations(context)}`;
       }
       const newReturnStatement = returnStatement.replace(/}$/, statement);
       existFunction.setBodyText(newReturnStatement);
     }
   } else {
-    classicFile.addFunction({
+    const functions = {
       name: operationFunctionName,
       isExported: true,
       parameters: [
         {
           name: "context",
-          type: client.rlcClientName
-        },
-        ...(hasSubscriptionIdPromoted
-          ? [{ name: "subscriptionId", type: "string" }]
-          : [])
+          type: rlcClientName
+        }
       ],
       returnType: `${getClassicalLayerPrefix(
-        operationGroup,
+        prefixes,
         NameType.Interface,
         "",
         layer
       )}Operations`,
       statements:
-        layer !== operationGroup.namespaceHierarchies.length - 1
+        layer !== prefixes.length - 1
           ? `return {
             ${normalizeName(
-              operationGroup.namespaceHierarchies[layer + 1] ?? "FIXME",
+              prefixes[layer + 1] ?? "FIXME",
               NameType.Property
             )}: get${getClassicalLayerPrefix(
-              operationGroup,
+              prefixes,
               NameType.Interface,
               "",
               layer + 1
@@ -255,13 +229,14 @@ export function getClassicalOperation(
       }`
           : `return {
         ...get${getClassicalLayerPrefix(
-          operationGroup,
+          prefixes,
           NameType.Interface,
           "",
           layer
-        )}(context${hasSubscriptionIdPromoted ? ", subscriptionId" : ""})
+        )}(context)
       }`
-    });
+    };
+    classicFile.addFunction(functions);
   }
 
   function getClassicalMethodName(