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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@azure-tools/typespec-ts",
-  "version": "0.36.0",
+  "version": "0.37.0-alpha.20241230.1",
   "description": "An experimental TypeSpec emitter for TypeScript RLC",
   "main": "dist/src/index.js",
   "type": "module",
@@ -44,7 +44,7 @@
     "@typespec/http": ">=0.63.0 <1.0.0",
     "@typespec/openapi": ">=0.63.0, <1.0.0",
     "@typespec/rest": ">=0.63.0 <1.0.0",
-    "@typespec/ts-http-runtime": "1.0.0-alpha.20240314.2",
+    "@typespec/ts-http-runtime": "0.1.0",
     "@typespec/versioning": ">=0.63.0 <1.0.0",
     "chai": "^4.3.6",
     "chalk": "^4.0.0",
@@ -73,7 +73,7 @@
     "@typespec/versioning": ">=0.63.0 <1.0.0"
   },
   "dependencies": {
-    "@azure-tools/rlc-common": "^0.36.0",
+    "@azure-tools/rlc-common": "^0.37.0",
     "fs-extra": "^11.1.0",
     "lodash": "^4.17.21",
     "prettier": "^3.3.3",

package/src/contextManager.ts

@@ -1,5 +1,5 @@
 import { Project, SourceFile } from "ts-morph";
-import { ModularMetaTree, RlcMetaTree } from "./metaTree.js";
+import { RlcMetaTree } from "./metaTree.js";
 import { EmitContext } from "@typespec/compiler";
 import { SdkContext } from "@azure-tools/typespec-client-generator-core";
 import { SdkTypeContext } from "./framework/hooks/sdkTypes.js";
@@ -21,7 +21,6 @@ import { ExternalDependencies } from "./framework/dependency.js";
  */
 type Contexts = {
   rlcMetaTree: RlcMetaTree; // Context for RLC types metadata.
-  modularMetaTree: ModularMetaTree; // Context for modular types metadata.
   outputProject: Project; // The TS-Morph root project context for code generation.
   symbolMap: Map<string, SourceFile>; // Mapping of symbols to their corresponding source files.
   sdkTypes: SdkTypeContext;

package/src/framework/load-static-helpers.ts

@@ -10,6 +10,8 @@ import {
 } from "ts-morph";
 import { refkey } from "./refkey.js";
 import { resolveProjectRoot } from "../utils/resolve-project-root.js";
+import { isAzurePackage } from "@azure-tools/rlc-common";
+import { ModularEmitterOptions } from "../modular/interfaces.js";
 export const SourceFileSymbol = Symbol("SourceFile");
 export interface StaticHelperMetadata {
   name: string;
@@ -34,7 +36,8 @@ export type StaticHelpers = Record<string, StaticHelperMetadata>;
 
 const DEFAULT_STATIC_HELPERS_PATH = "static/static-helpers";
 
-export interface LoadStaticHelpersOptions {
+export interface LoadStaticHelpersOptions
+  extends Partial<ModularEmitterOptions> {
   helpersAssetDirectory?: string;
   sourcesDir?: string;
 }
@@ -60,6 +63,26 @@ export async function loadStaticHelpers(
     const addedFile = project.createSourceFile(targetPath, contents, {
       overwrite: true
     });
+    addedFile.getImportDeclarations().map((i) => {
+      if (!isAzurePackage({ options: options.options })) {
+        if (
+          i
+            .getModuleSpecifier()
+            .getFullText()
+            .includes("@azure/core-rest-pipeline")
+        ) {
+          i.setModuleSpecifier("@typespec/ts-http-runtime");
+        }
+        if (
+          i
+            .getModuleSpecifier()
+            .getFullText()
+            .includes("@azure-rest/core-client")
+        ) {
+          i.setModuleSpecifier("@typespec/ts-http-runtime");
+        }
+      }
+    });
 
     for (const entry of Object.values(helpers)) {
       if (!addedFile.getFilePath().endsWith(entry.location)) {

package/src/index.ts

@@ -55,7 +55,7 @@ import { emitContentByBuilder, emitModels } from "./utils/emitUtil.js";
 import { provideContext, useContext } from "./contextManager.js";
 
 import { EmitterOptions } from "./lib.js";
-import { ModularCodeModel } from "./modular/modularCodeModel.js";
+import { ModularEmitterOptions } from "./modular/interfaces.js";
 import { Project, SourceFile } from "ts-morph";
 import { buildClassicOperationFiles } from "./modular/buildClassicalOperationGroups.js";
 import { buildClassicalClient } from "./modular/buildClassicalClient.js";
@@ -68,7 +68,7 @@ import { buildOperationFiles } from "./modular/buildOperations.js";
 import { buildRestorePoller } from "./modular/buildRestorePoller.js";
 import { buildSubpathIndexFile } from "./modular/buildSubpathIndex.js";
 import { createSdkContext } from "@azure-tools/typespec-client-generator-core";
-import { emitCodeModel } from "./modular/buildCodeModel.js";
+import { transformModularEmitterOptions } from "./modular/buildModularOptions.js";
 import { emitLoggerFile } from "./modular/emitLoggerFile.js";
 import { emitSerializerHelpersFile } from "./modular/buildHelperSerializers.js";
 import { emitTypes } from "./modular/emitModels.js";
@@ -105,7 +105,6 @@ export async function $onEmit(context: EmitContext) {
   >();
   provideContext("rlcMetaTree", new Map());
   provideContext("symbolMap", new Map());
-  provideContext("modularMetaTree", new Map());
   provideContext("outputProject", outputProject);
   provideContext("emitContext", {
     compilerContext: context,
@@ -118,7 +117,10 @@ export async function $onEmit(context: EmitContext) {
       ...PagingHelpers,
       ...PollingHelpers
     },
-    { sourcesDir: dpgContext.generationPathDetail?.modularSourcesDir }
+    {
+      sourcesDir: dpgContext.generationPathDetail?.modularSourcesDir,
+      options: rlcOptions
+    }
   );
   const extraDependencies = isAzurePackage({ options: rlcOptions })
     ? {
@@ -136,8 +138,7 @@ export async function $onEmit(context: EmitContext) {
   provideSdkTypes(dpgContext);
 
   const rlcCodeModels: RLCModel[] = [];
-  let modularCodeModel: ModularCodeModel;
-
+  let modularEmitterOptions: ModularEmitterOptions;
   // 1. Clear sources folder
   await clearSrcFolder();
   // 2. Generate RLC code model
@@ -152,7 +153,7 @@ export async function $onEmit(context: EmitContext) {
   }
 
   // 5. Generate metadata and test files
-  await generateMetadataAndTest();
+  await generateMetadataAndTest(dpgContext);
 
   async function enrichDpgContext() {
     const generationPathDetail: GenerationDirDetail =
@@ -243,9 +244,8 @@ export async function $onEmit(context: EmitContext) {
       dpgContext.generationPathDetail?.modularSourcesDir ?? "src";
     const project = useContext("outputProject");
     emitSerializerHelpersFile(project, modularSourcesRoot);
-    modularCodeModel = emitCodeModel(
+    modularEmitterOptions = transformModularEmitterOptions(
       dpgContext,
-      serviceNameToRlcModelsMap,
       modularSourcesRoot,
       project,
       {
@@ -253,7 +253,7 @@ export async function $onEmit(context: EmitContext) {
       }
     );
 
-    emitLoggerFile(modularCodeModel, project, modularSourcesRoot);
+    emitLoggerFile(modularEmitterOptions, modularSourcesRoot);
 
     const rootIndexFile = project.createSourceFile(
       `${modularSourcesRoot}/index.ts`,
@@ -263,10 +263,10 @@ export async function $onEmit(context: EmitContext) {
       }
     );
 
-    const isMultiClients = modularCodeModel.clients.length > 1;
+    const isMultiClients = dpgContext.sdkPackage.clients.length > 1;
 
     emitTypes(dpgContext, { sourceRoot: modularSourcesRoot });
-    buildSubpathIndexFile(modularCodeModel, "models");
+    buildSubpathIndexFile(dpgContext, modularEmitterOptions, "models");
     // Enable modular sample generation when explicitly set to true or MPG
     if (emitterOptions?.generateSample === true) {
       const samples = emitSamples(dpgContext);
@@ -276,29 +276,51 @@ export async function $onEmit(context: EmitContext) {
         dpgContext.rlcOptions!.generateSample = true;
       }
     }
-    for (const subClient of modularCodeModel.clients) {
-      buildApiOptions(dpgContext, subClient, modularCodeModel);
-      buildOperationFiles(subClient, dpgContext, modularCodeModel);
-      buildClientContext(subClient, dpgContext, modularCodeModel);
-      buildRestorePoller(modularCodeModel, subClient);
+    for (const subClient of dpgContext.sdkPackage.clients) {
+      buildApiOptions(dpgContext, subClient, modularEmitterOptions);
+      buildOperationFiles(dpgContext, subClient, modularEmitterOptions);
+      buildClientContext(dpgContext, subClient, modularEmitterOptions);
+      buildRestorePoller(dpgContext, subClient, modularEmitterOptions);
       if (dpgContext.rlcOptions?.hierarchyClient) {
-        buildSubpathIndexFile(modularCodeModel, "api", subClient);
+        buildSubpathIndexFile(
+          dpgContext,
+          modularEmitterOptions,
+          "api",
+          subClient
+        );
       } else {
-        buildSubpathIndexFile(modularCodeModel, "api", subClient, {
-          exportIndex: true
-        });
+        buildSubpathIndexFile(
+          dpgContext,
+          modularEmitterOptions,
+          "api",
+          subClient,
+          {
+            exportIndex: true
+          }
+        );
       }
 
-      buildClassicalClient(subClient, dpgContext, modularCodeModel);
-      buildClassicOperationFiles(dpgContext, modularCodeModel, subClient);
-      buildSubpathIndexFile(modularCodeModel, "classic", subClient, {
-        exportIndex: true,
-        interfaceOnly: true
-      });
+      buildClassicalClient(dpgContext, subClient, modularEmitterOptions);
+      buildClassicOperationFiles(dpgContext, subClient, modularEmitterOptions);
+      buildSubpathIndexFile(
+        dpgContext,
+        modularEmitterOptions,
+        "classic",
+        subClient,
+        {
+          exportIndex: true,
+          interfaceOnly: true
+        }
+      );
       if (isMultiClients) {
-        buildSubClientIndexFile(subClient, modularCodeModel);
+        buildSubClientIndexFile(dpgContext, subClient, modularEmitterOptions);
       }
-      buildRootIndex(subClient, modularCodeModel, rootIndexFile);
+      buildRootIndex(
+        dpgContext,
+        subClient,
+        modularEmitterOptions,
+        rootIndexFile
+      );
     }
 
     binder.resolveAllReferences(modularSourcesRoot);
@@ -318,12 +340,12 @@ export async function $onEmit(context: EmitContext) {
       await emitContentByBuilder(
         program,
         () => ({ content: file.getFullText(), path: file.getFilePath() }),
-        modularCodeModel as any
+        modularEmitterOptions as any
       );
     }
   }
 
-  async function generateMetadataAndTest() {
+  async function generateMetadataAndTest(context: SdkContext) {
     const project = useContext("outputProject");
     if (rlcCodeModels.length === 0 || !rlcCodeModels[0]) {
       return;
@@ -359,7 +381,7 @@ export async function $onEmit(context: EmitContext) {
       let modularPackageInfo = {};
       if (option.isModularLibrary) {
         modularPackageInfo = {
-          exports: getModuleExports(modularCodeModel)
+          exports: getModuleExports(context, modularEmitterOptions)
         };
         if (isAzureFlavor) {
           modularPackageInfo = {
@@ -367,7 +389,10 @@ export async function $onEmit(context: EmitContext) {
             dependencies: {
               "@azure/core-util": "^1.9.2"
             },
-            clientContextPaths: getRelativeContextPaths(modularCodeModel)
+            clientContextPaths: getRelativeContextPaths(
+              context,
+              modularEmitterOptions
+            )
           };
         }
       }
@@ -388,7 +413,7 @@ export async function $onEmit(context: EmitContext) {
           await emitContentByBuilder(
             program,
             () => ({ content: file.getFullText(), path: file.getFilePath() }),
-            modularCodeModel as any
+            modularEmitterOptions as any
           );
         }
       }
@@ -413,9 +438,12 @@ export async function $onEmit(context: EmitContext) {
     }
   }
 
-  function getRelativeContextPaths(codeModel: ModularCodeModel) {
-    return codeModel.clients
-      .map((subClient) => getClientContextPath(subClient, codeModel))
+  function getRelativeContextPaths(
+    context: SdkContext,
+    options: ModularEmitterOptions
+  ) {
+    return context.sdkPackage.clients
+      .map((subClient) => getClientContextPath(context, subClient, options))
       .map((path) => path.substring(path.indexOf("src")));
   }
 }

package/src/lib.ts

@@ -116,7 +116,7 @@ const libDef = {
       }
     },
     "no-service-defined": {
-      severity: "error",
+      severity: "warning",
       messages: {
         default:
           "No service defined and must have one and only one service defined."

package/src/metaTree.ts

@@ -1,14 +1,8 @@
 import { Schema as RlcType } from "@azure-tools/rlc-common";
-import { Type as ModularType } from "./modular/modularCodeModel.js";
 import { Type } from "@typespec/compiler";
 
 export interface RlcTypeMetadata {
   rlcType: RlcType;
 }
 
-export interface ModularTypeMetadata {
-  modularType: ModularType;
-}
-
 export type RlcMetaTree = Map<Type, RlcTypeMetadata>;
-export type ModularMetaTree = Map<Type, ModularTypeMetadata>;

package/src/modular/buildClassicalClient.ts

@@ -5,7 +5,7 @@ import {
   SourceFile,
   StructureKind
 } from "ts-morph";
-import { Client, ModularCodeModel } from "./modularCodeModel.js";
+import { ModularEmitterOptions } from "./interfaces.js";
 import { NameType, normalizeName } from "@azure-tools/rlc-common";
 import {
   buildUserAgentOptions,
@@ -13,39 +13,48 @@ import {
 } from "./helpers/clientHelpers.js";
 import {
   getClassicalClientName,
-  getClassicalLayerPrefix,
   getClientName
 } from "./helpers/namingHelpers.js";
 
 import { SdkContext } from "../utils/interfaces.js";
 import { getDocsFromDescription } from "./helpers/docsHelpers.js";
 import { getOperationFunction } from "./helpers/operationHelpers.js";
-import { isRLCMultiEndpoint } from "../utils/clientUtils.js";
+import {
+  getModularClientOptions,
+  isRLCMultiEndpoint
+} from "../utils/clientUtils.js";
 import { resolveReference } from "../framework/reference.js";
-import { shouldPromoteSubscriptionId } from "./helpers/classicalOperationHelpers.js";
 import { useDependencies } from "../framework/hooks/useDependencies.js";
+import {
+  SdkClientType,
+  SdkServiceMethod,
+  SdkServiceOperation
+} from "@azure-tools/typespec-client-generator-core";
+import { getMethodHierarchiesMap } from "../utils/operationUtil.js";
 
 export function buildClassicalClient(
-  _client: Client,
   dpgContext: SdkContext,
-  codeModel: ModularCodeModel
+  client: SdkClientType<SdkServiceOperation>,
+  emitterOptions: ModularEmitterOptions
 ) {
-  const { description, tcgcClient: client } = _client;
   const dependencies = useDependencies();
   const modularClientName = getClientName(client);
   const classicalClientName = `${getClassicalClientName(client)}`;
-  const classicalParams = getClientParametersDeclaration(_client, dpgContext, {
+  const classicalParams = getClientParametersDeclaration(client, dpgContext, {
     requiredOnly: true
   });
-  const contextParams = getClientParametersDeclaration(_client, dpgContext, {
-    onClientOnly: true,
+  const contextParams = getClientParametersDeclaration(client, dpgContext, {
+    onClientOnly: false,
     requiredOnly: true
   });
-  const srcPath = codeModel.modularOptions.sourceRoot;
-  const subfolder = _client.subfolder ?? "";
+  const srcPath = emitterOptions.modularOptions.sourceRoot;
+  const { subfolder, rlcClientName } = getModularClientOptions(
+    dpgContext,
+    client
+  );
 
-  const clientFile = codeModel.project.createSourceFile(
-    `${srcPath}/${subfolder !== "" ? subfolder + "/" : ""}${normalizeName(
+  const clientFile = emitterOptions.project.createSourceFile(
+    `${srcPath}/${subfolder && subfolder !== "" ? subfolder + "/" : ""}${normalizeName(
       classicalClientName,
       NameType.File
     )}.ts`
@@ -68,13 +77,13 @@ export function buildClassicalClient(
   if (isRLCMultiEndpoint(dpgContext)) {
     clientClass.addProperty({
       name: "_client",
-      type: `Client.${_client.rlcClientName}`,
+      type: `Client.${rlcClientName}`,
       scope: Scope.Private
     });
   } else {
     clientClass.addProperty({
       name: "_client",
-      type: `${_client.rlcClientName}`,
+      type: `${rlcClientName}`,
       scope: Scope.Private
     });
   }
@@ -89,7 +98,7 @@ export function buildClassicalClient(
 
   // TODO: We may need to generate constructor overloads at some point. Here we'd do that.
   const constructor = clientClass.addConstructor({
-    docs: getDocsFromDescription(description),
+    docs: getDocsFromDescription(client.doc),
     parameters: classicalParams
   });
 
@@ -99,7 +108,7 @@ export function buildClassicalClient(
       if (x === "options") {
         return `{...options, userAgentOptions: ${buildUserAgentOptions(
           constructor,
-          codeModel,
+          emitterOptions,
           "azsdk-js-client"
         )}}`;
       } else {
@@ -112,8 +121,8 @@ export function buildClassicalClient(
   ]);
   constructor.addStatements(`this.pipeline = this._client.pipeline;`);
 
-  buildClientOperationGroups(clientFile, _client, dpgContext, clientClass);
-  importAllApis(clientFile, srcPath, subfolder);
+  buildClientOperationGroups(clientFile, client, dpgContext, clientClass);
+  importAllApis(clientFile, srcPath, subfolder ?? "");
   clientFile.fixUnusedIdentifiers();
   return clientFile;
 }
@@ -125,7 +134,7 @@ function importAllApis(
 ) {
   const project = clientFile.getProject();
   const apiModels = project.getSourceFile(
-    `${srcPath}/${subfolder !== "" ? subfolder + "/" : ""}api/index.ts`
+    `${srcPath}/${subfolder && subfolder !== "" ? subfolder + "/" : ""}api/index.ts`
   );
 
   if (!apiModels) {
@@ -140,96 +149,85 @@ function importAllApis(
   });
 }
 
+function generateMethod(
+  context: SdkContext,
+  clientType: string,
+  method: [string[], SdkServiceMethod<SdkServiceOperation>]
+) {
+  const declarations = getOperationFunction(context, method, clientType);
+  const result: MethodDeclarationStructure = {
+    docs: declarations.docs,
+    name: declarations.propertyName ?? declarations.name ?? "FIXME",
+    kind: StructureKind.Method,
+    returnType: declarations.returnType,
+    parameters: declarations.parameters?.filter((p) => p.name !== "context"),
+    statements: `return ${declarations.name}(${[
+      "this._client",
+      ...[
+        declarations.parameters
+          ?.map((p) => p.name)
+          .filter((p) => p !== "context")
+      ]
+    ].join(",")})`
+  };
+  return result;
+}
 function buildClientOperationGroups(
   clientFile: SourceFile,
-  client: Client,
+  client: SdkClientType<SdkServiceOperation>,
   dpgContext: SdkContext,
   clientClass: ClassDeclaration
 ) {
   let clientType = "Client";
-  const subfolder = client.subfolder ?? "";
+  const { subfolder } = getModularClientOptions(dpgContext, client);
   if (subfolder && subfolder !== "") {
     clientType = `Client.${clientClass.getName()}`;
   }
-  for (const operationGroup of client.operationGroups) {
-    const groupName = normalizeName(
-      operationGroup.namespaceHierarchies[0] ?? operationGroup.propertyName,
-      NameType.Property
-    );
-    // TODO: remove this logic once client-level parameter design is finalized
-    // https://github.com/Azure/autorest.typescript/issues/2618
-    const hasSubscriptionIdPromoted = shouldPromoteSubscriptionId(
-      dpgContext,
-      operationGroup
-    );
-    if (groupName === "") {
-      operationGroup.operations.forEach((op) => {
-        const declarations = getOperationFunction(dpgContext, op, clientType);
-        const method: MethodDeclarationStructure = {
-          docs: declarations.docs,
-          name: declarations.propertyName ?? declarations.name ?? "FIXME",
-          kind: StructureKind.Method,
-          returnType: declarations.returnType,
-          parameters: declarations.parameters?.filter(
-            (p) => p.name !== "context"
-          ),
-          statements: `return ${declarations.name}(${[
-            "this._client",
-            ...[
-              declarations.parameters
-                ?.map((p) => p.name)
-                .filter((p) => p !== "context")
-            ]
-          ].join(",")})`
-        };
+  const methodMap = getMethodHierarchiesMap(dpgContext, client);
+  for (const [prefixKey, operations] of methodMap) {
+    const prefixes = prefixKey.split("/");
+    if (prefixKey === "") {
+      operations.forEach((op) => {
+        const method = generateMethod(dpgContext, clientType, [prefixes, op]);
         clientClass.addMethod(method);
       });
-      continue;
-    }
-    const operationName = `get${getClassicalLayerPrefix(
-      operationGroup,
-      NameType.Interface,
-      "",
-      0
-    )}Operations`;
-    const propertyType = `${getClassicalLayerPrefix(
-      operationGroup,
-      NameType.Interface,
-      "",
-      0
-    )}Operations`;
-    const existProperty = clientClass.getProperties().filter((p) => {
-      return p.getName() === groupName;
-    });
-    if (!existProperty || existProperty.length === 0) {
-      clientFile.addImportDeclaration({
-        namedImports: [operationName, propertyType],
-        moduleSpecifier: `./classic/${getClassicalLayerPrefix(
-          operationGroup,
-          NameType.File,
-          "/",
-          0
-        )}/index.js`
+    } else {
+      const groupName = normalizeName(prefixes[0] ?? "", NameType.Property);
+      const operationName = `get${normalizeName(
+        groupName,
+        NameType.OperationGroup
+      )}Operations`;
+      const propertyType = `${normalizeName(
+        groupName,
+        NameType.OperationGroup
+      )}Operations`;
+      const existProperty = clientClass.getProperties().filter((p) => {
+        return p.getName() === groupName;
       });
-      clientClass.addProperty({
-        name: groupName,
-        type: propertyType,
-        scope: Scope.Public,
-        isReadonly: true,
-        docs: ["The operation groups for " + operationGroup.propertyName]
-      });
-      clientClass
-        .getConstructors()[0]
-        ?.addStatements(
-          `this.${groupName} = get${getClassicalLayerPrefix(
-            operationGroup,
-            NameType.Interface,
-            "",
-            0
-          )}Operations(this._client${
-            hasSubscriptionIdPromoted ? ", subscriptionId" : ""
-          })`
-        );
+      if (!existProperty || existProperty.length === 0) {
+        clientFile.addImportDeclaration({
+          namedImports: [operationName, propertyType],
+          moduleSpecifier: `./classic/${normalizeName(
+            groupName,
+            NameType.File
+          )}/index.js`
+        });
+        clientClass.addProperty({
+          name: groupName,
+          type: propertyType,
+          scope: Scope.Public,
+          isReadonly: true,
+          docs: ["The operation groups for " + groupName]
+        });
+        clientClass
+          .getConstructors()[0]
+          ?.addStatements(
+            `this.${groupName} = get${normalizeName(
+              groupName,
+              NameType.OperationGroup
+            )}Operations(this._client)`
+          );
+      }
     }
   }
 }