@azure-tools/typespec-ts 0.31.0 → 0.32.0

package/src/index.ts

@@ -28,7 +28,9 @@ import {
   hasUnexpectedHelper,
   RLCModel,
   RLCOptions,
-  buildLicenseFile
+  buildLicenseFile,
+  updatePackageFile,
+  isAzurePackage
 } from "@azure-tools/rlc-common";
 import { createSdkContext } from "@azure-tools/typespec-client-generator-core";
 import { EmitContext, Program } from "@typespec/compiler";
@@ -42,15 +44,7 @@ import { buildClassicalClient } from "./modular/buildClassicalClient.js";
 import { buildClassicOperationFiles } from "./modular/buildClassicalOperationGroups.js";
 import { buildClientContext } from "./modular/buildClientContext.js";
 import { emitCodeModel } from "./modular/buildCodeModel.js";
-import {
-  buildGetPollerHelper,
-  buildRestorePollerHelper
-} from "./modular/buildLroFiles.js";
 import { buildOperationFiles } from "./modular/buildOperations.js";
-import {
-  buildPagingHelpers as buildModularPagingHelpers,
-  buildPagingTypes
-} from "./modular/buildPagingFiles.js";
 import { getModuleExports } from "./modular/buildProjectFiles.js";
 import {
   buildRootIndex,
@@ -68,14 +62,33 @@ import { GenerationDirDetail, SdkContext } from "./utils/interfaces.js";
 import { provideContext, useContext } from "./contextManager.js";
 import { emitSerializerHelpersFile } from "./modular/buildHelperSerializers.js";
 import { provideSdkTypes } from "./framework/hooks/sdkTypes.js";
+import { provideBinder } from "./framework/hooks/binder.js";
+import { loadStaticHelpers } from "./framework/load-static-helpers.js";
+import {
+  PagingHelpers,
+  PollingHelpers,
+  SerializationHelpers
+} from "./modular/static-helpers-metadata.js";
+import {
+  AzureCoreDependencies,
+  AzurePollingDependencies
+} from "./modular/external-dependencies.js";
+import { emitLoggerFile } from "./modular/emitLoggerFile.js";
+import { buildRestorePoller } from "./modular/buildRestorePoller.js";
 
 export * from "./lib.js";
 
 export async function $onEmit(context: EmitContext) {
   /** Shared status */
+  const outputProject = new Project();
   const program: Program = context.program;
   const emitterOptions: EmitterOptions = context.options;
-  const dpgContext = createContextWithDefaultOptions(context);
+  const dpgContext = await createContextWithDefaultOptions(context);
+  const rlcOptions: RLCOptions = transformRLCOptions(
+    emitterOptions,
+    dpgContext
+  );
+
   const needUnexpectedHelper: Map<string, boolean> = new Map<string, boolean>();
   const serviceNameToRlcModelsMap: Map<string, RLCModel> = new Map<
     string,
@@ -84,12 +97,31 @@ export async function $onEmit(context: EmitContext) {
   provideContext("rlcMetaTree", new Map());
   provideContext("symbolMap", new Map());
   provideContext("modularMetaTree", new Map());
-  provideContext("outputProject", new Project());
+  provideContext("outputProject", outputProject);
   provideContext("emitContext", {
     compilerContext: context,
     tcgcContext: dpgContext
   });
   provideSdkTypes(dpgContext.sdkPackage);
+  const { modularSourcesDir } = await calculateGenerationDir(rlcOptions);
+  const staticHelpers = await loadStaticHelpers(
+    outputProject,
+    {
+      ...SerializationHelpers,
+      ...PagingHelpers,
+      ...PollingHelpers
+    },
+    { sourcesDir: modularSourcesDir }
+  );
+  const extraDependencies = isAzurePackage({ options: rlcOptions })
+    ? { ...AzurePollingDependencies, ...AzureCoreDependencies }
+    : {};
+  const binder = provideBinder(outputProject, {
+    staticHelpers,
+    dependencies: {
+      ...extraDependencies
+    }
+  });
 
   const rlcCodeModels: RLCModel[] = [];
   let modularCodeModel: ModularCodeModel;
@@ -97,36 +129,49 @@ export async function $onEmit(context: EmitContext) {
   await enrichDpgContext();
   // 2. Clear sources folder
   await clearSrcFolder();
-  // 3. Generate RLC sources
-  await generateRLCSources();
-  // 4. Generate Modular sources
-  await generateModularSources();
+  // 3. Generate RLC code model
+  // TODO: skip this step in modular once modular generator is sufficiently decoupled
+  await buildRLCCodeModels();
+
+  // 4. Generate sources
+  if (emitterOptions.isModularLibrary) {
+    await generateModularSources();
+  } else {
+    await generateRLCSources();
+  }
+
   // 5. Generate metadata and test files
   await generateMetadataAndTest();
 
   async function enrichDpgContext() {
+    const options: RLCOptions = transformRLCOptions(emitterOptions, dpgContext);
     const generationPathDetail: GenerationDirDetail =
-      await calculateGenerationDir();
+      await calculateGenerationDir(options);
     dpgContext.generationPathDetail = generationPathDetail;
-    const options: RLCOptions = transformRLCOptions(emitterOptions, dpgContext);
     const hasTestFolder = await fsextra.pathExists(
       join(dpgContext.generationPathDetail?.metadataDir ?? "", "test")
     );
-    options.generateTest =
-      options.generateTest === true ||
-      (options.generateTest === undefined &&
+    rlcOptions.generateTest =
+      rlcOptions.generateTest === true ||
+      (rlcOptions.generateTest === undefined &&
         !hasTestFolder &&
-        options.flavor === "azure");
-    dpgContext.rlcOptions = options;
+        isAzurePackage({ options: rlcOptions }));
+    dpgContext.rlcOptions = rlcOptions;
   }
 
-  async function calculateGenerationDir(): Promise<GenerationDirDetail> {
-    const projectRoot = context.emitterOutputDir ?? "";
-    let sourcesRoot = join(projectRoot, "src");
-    const customizationFolder = join(projectRoot, "sources");
-    if (await fsextra.pathExists(customizationFolder)) {
-      sourcesRoot = join(customizationFolder, "generated", "src");
+  async function calculateGenerationDir(
+    options: RLCOptions
+  ): Promise<GenerationDirDetail> {
+    // clear output folder if needed
+    if (options.clearOutputFolder) {
+      await fsextra.emptyDir(context.emitterOutputDir);
     }
+    const projectRoot = context.emitterOutputDir ?? "";
+    const customizationFolder = join(projectRoot, "generated");
+    // if customization folder exists, use it as sources root
+    const sourcesRoot = (await fsextra.pathExists(customizationFolder))
+      ? customizationFolder
+      : join(projectRoot, "src");
     return {
       rootDir: projectRoot,
       metadataDir: projectRoot,
@@ -148,7 +193,7 @@ export async function $onEmit(context: EmitContext) {
     );
   }
 
-  async function generateRLCSources() {
+  async function buildRLCCodeModels() {
     const clients = getRLCClients(dpgContext);
     for (const client of clients) {
       const rlcModels = await transformRLCModel(client, dpgContext);
@@ -158,7 +203,11 @@ export async function $onEmit(context: EmitContext) {
         getClientName(rlcModels),
         hasUnexpectedHelper(rlcModels)
       );
+    }
+  }
 
+  async function generateRLCSources() {
+    for (const rlcModels of rlcCodeModels) {
       await emitModels(rlcModels, program);
       await emitContentByBuilder(program, buildClientDefinitions, rlcModels);
       await emitContentByBuilder(program, buildResponseTypes, rlcModels);
@@ -181,90 +230,72 @@ export async function $onEmit(context: EmitContext) {
   }
 
   async function generateModularSources() {
-    if (emitterOptions.isModularLibrary) {
-      // TODO: Emit modular parts of the library
-      const modularSourcesRoot =
-        dpgContext.generationPathDetail?.modularSourcesDir ?? "src";
-      const project = useContext("outputProject");
-      emitSerializerHelpersFile(project, modularSourcesRoot);
-      modularCodeModel = emitCodeModel(
-        dpgContext,
-        serviceNameToRlcModelsMap,
-        modularSourcesRoot,
-        project,
-        {
-          casing: "camel"
-        }
-      );
-      const rootIndexFile = project.createSourceFile(
-        `${modularSourcesRoot}/index.ts`,
-        "",
-        {
-          overwrite: true
-        }
-      );
+    const modularSourcesRoot =
+      dpgContext.generationPathDetail?.modularSourcesDir ?? "src";
+    const project = useContext("outputProject");
+    emitSerializerHelpersFile(project, modularSourcesRoot);
+    modularCodeModel = emitCodeModel(
+      dpgContext,
+      serviceNameToRlcModelsMap,
+      modularSourcesRoot,
+      project,
+      {
+        casing: "camel"
+      }
+    );
 
-      const isMultiClients = modularCodeModel.clients.length > 1;
-      for (const subClient of modularCodeModel.clients) {
-        buildModels(subClient, modularCodeModel);
-        buildModelsOptions(subClient, modularCodeModel);
-        const hasClientUnexpectedHelper =
-          needUnexpectedHelper.get(subClient.rlcClientName) ?? false;
-        if (!env["EXPERIMENTAL_TYPESPEC_TS_SERIALIZATION"])
-          buildSerializeUtils(modularCodeModel);
-        // build paging files
-        buildPagingTypes(subClient, modularCodeModel);
-        buildModularPagingHelpers(
-          subClient,
-          modularCodeModel,
-          hasClientUnexpectedHelper,
-          isMultiClients
-        );
-        // build operation files
-        buildOperationFiles(
-          subClient,
-          dpgContext,
-          modularCodeModel,
-          hasClientUnexpectedHelper
-        );
-        buildClientContext(subClient, dpgContext, modularCodeModel);
-        buildSubpathIndexFile(subClient, modularCodeModel, "models");
-        // build lro files
-        buildGetPollerHelper(
-          modularCodeModel,
-          subClient,
-          hasClientUnexpectedHelper,
-          isMultiClients
-        );
-        buildRestorePollerHelper(modularCodeModel, subClient);
-        if (dpgContext.rlcOptions?.hierarchyClient) {
-          buildSubpathIndexFile(subClient, modularCodeModel, "api");
-        } else {
-          buildSubpathIndexFile(subClient, modularCodeModel, "api", {
-            exportIndex: true
-          });
-        }
+    emitLoggerFile(modularCodeModel, project, modularSourcesRoot);
 
-        buildClassicalClient(subClient, dpgContext, modularCodeModel);
-        buildClassicOperationFiles(dpgContext, modularCodeModel, subClient);
-        buildSubpathIndexFile(subClient, modularCodeModel, "classic", {
-          exportIndex: true,
-          interfaceOnly: true
+    const rootIndexFile = project.createSourceFile(
+      `${modularSourcesRoot}/index.ts`,
+      "",
+      {
+        overwrite: true
+      }
+    );
+
+    const isMultiClients = modularCodeModel.clients.length > 1;
+
+    for (const subClient of modularCodeModel.clients) {
+      buildModels(subClient, modularCodeModel);
+      buildModelsOptions(subClient, modularCodeModel);
+      if (!env["EXPERIMENTAL_TYPESPEC_TS_SERIALIZATION"])
+        buildSerializeUtils(modularCodeModel);
+      // build operation files
+      buildOperationFiles(subClient, dpgContext, modularCodeModel);
+      buildClientContext(subClient, dpgContext, modularCodeModel);
+      buildSubpathIndexFile(subClient, modularCodeModel, "models");
+      buildRestorePoller(modularCodeModel, subClient);
+      if (dpgContext.rlcOptions?.hierarchyClient) {
+        buildSubpathIndexFile(subClient, modularCodeModel, "api");
+      } else {
+        buildSubpathIndexFile(subClient, modularCodeModel, "api", {
+          exportIndex: true
         });
-        if (isMultiClients) {
-          buildSubClientIndexFile(subClient, modularCodeModel);
-        }
-        buildRootIndex(subClient, modularCodeModel, rootIndexFile);
       }
 
-      for (const file of project.getSourceFiles()) {
-        await emitContentByBuilder(
-          program,
-          () => ({ content: file.getFullText(), path: file.getFilePath() }),
-          modularCodeModel as any
-        );
-        // emitFile(program, { content: hrlcClient.content, path: hrlcClient.path });
+      buildClassicalClient(subClient, dpgContext, modularCodeModel);
+      buildClassicOperationFiles(dpgContext, modularCodeModel, subClient);
+      buildSubpathIndexFile(subClient, modularCodeModel, "classic", {
+        exportIndex: true,
+        interfaceOnly: true
+      });
+      if (isMultiClients) {
+        buildSubClientIndexFile(subClient, modularCodeModel);
       }
+      buildRootIndex(subClient, modularCodeModel, rootIndexFile);
+    }
+
+    binder.resolveAllReferences();
+
+    for (const file of project.getSourceFiles()) {
+      file.fixMissingImports({}, { importModuleSpecifierEnding: "js" });
+      file.fixUnusedIdentifiers();
+      await emitContentByBuilder(
+        program,
+        () => ({ content: file.getFullText(), path: file.getFilePath() }),
+        modularCodeModel as any
+      );
     }
   }
 
@@ -274,11 +305,13 @@ export async function $onEmit(context: EmitContext) {
     }
     const rlcClient: RLCModel = rlcCodeModels[0];
     const option = dpgContext.rlcOptions!;
-    const isAzureFlavor = option.flavor === "azure";
+    const isAzureFlavor = isAzurePackage({ options: option });
     // Generate metadata
-    const hasPackageFile = await existsSync(
-      join(dpgContext.generationPathDetail?.metadataDir ?? "", "package.json")
+    const existingPackageFilePath = join(
+      dpgContext.generationPathDetail?.metadataDir ?? "",
+      "package.json"
     );
+    const hasPackageFile = await existsSync(existingPackageFilePath);
     const shouldGenerateMetadata =
       option.generateMetadata === true ||
       (option.generateMetadata === undefined && !hasPackageFile);
@@ -321,6 +354,14 @@ export async function $onEmit(context: EmitContext) {
           );
         }
       }
+    } else if (hasPackageFile) {
+      // update existing package.json file with correct dependencies
+      await emitContentByBuilder(
+        program,
+        (model) => updatePackageFile(model, existingPackageFilePath),
+        rlcClient,
+        dpgContext.generationPathDetail?.metadataDir
+      );
     }
 
     // Generate test relevant files
@@ -335,9 +376,9 @@ export async function $onEmit(context: EmitContext) {
   }
 }
 
-export function createContextWithDefaultOptions(
+export async function createContextWithDefaultOptions(
   context: EmitContext<Record<string, any>>
-): SdkContext {
+): Promise<SdkContext> {
   const tcgcSettings = {
     "generate-protocol-methods": true,
     "generate-convenience-methods": true,
@@ -354,5 +395,5 @@ export function createContextWithDefaultOptions(
     ...tcgcSettings
   };
 
-  return createSdkContext(context) as SdkContext;
+  return (await createSdkContext(context)) as SdkContext;
 }

package/src/lib.ts

@@ -92,7 +92,8 @@ export const RLCOptionsSchema: JSONSchemaType<EmitterOptions> = {
       default: "esm"
     },
     compatibilityMode: { type: "boolean", nullable: true },
-    experimentalExtensibleEnums: { type: "boolean", nullable: true }
+    experimentalExtensibleEnums: { type: "boolean", nullable: true },
+    clearOutputFolder: { type: "boolean", nullable: true }
   },
   required: []
 };
@@ -237,6 +238,12 @@ const libDef = {
       messages: {
         default: paramMessage`Please note the body type of default response for operation - ${"operationName"} is not a model type.`
       }
+    },
+    "un-supported-credential": {
+      severity: "warning",
+      messages: {
+        default: paramMessage`Authentication type ${"credentialType"} is not supported.`
+      }
     }
   },
   emitter: {

package/src/modular/buildClassicalClient.ts

@@ -13,10 +13,9 @@ import {
 } from "ts-morph";
 import { isRLCMultiEndpoint } from "../utils/clientUtils.js";
 import { SdkContext } from "../utils/interfaces.js";
-import { importLroCoreDependencies } from "./buildLroFiles.js";
 import {
+  buildUserAgentOptions,
   getClientParameters,
-  getUserAgentStatements,
   importCredential
 } from "./helpers/clientHelpers.js";
 import { getDocsFromDescription } from "./helpers/docsHelpers.js";
@@ -91,25 +90,28 @@ export function buildClassicalClient(
     parameters: classicalParams
   });
 
-  const paramNames = (contextParams ?? []).map((p) => p.name);
-  const { updatedParamNames, userAgentStatements } = getUserAgentStatements(
-    "azsdk-js-client",
-    paramNames
-  );
+  const paramNames = (contextParams ?? [])
+    .map((p) => p.name)
+    .map((x) => {
+      if (x === "options") {
+        return `{...options, userAgentOptions: ${buildUserAgentOptions(
+          constructor,
+          "azsdk-js-client"
+        )}}`;
+      } else {
+        return x;
+      }
+    });
 
   constructor.addStatements([
-    userAgentStatements,
-    `this._client = create${modularClientName}(${updatedParamNames.join(",")})`
+    `this._client = create${modularClientName}(${paramNames.join(",")})`
   ]);
   constructor.addStatements(`this.pipeline = this._client.pipeline`);
-  importLroCoreDependencies(clientFile);
   importCredential(codeModel.runtimeImports, clientFile);
   importPipeline(codeModel.runtimeImports, clientFile);
   importAllModels(clientFile, srcPath, subfolder);
   buildClientOperationGroups(clientFile, client, dpgContext, clientClass);
   importAllApis(clientFile, srcPath, subfolder);
-  clientFile.fixMissingImports();
-  clientFile.fixUnusedIdentifiers();
   return clientFile;
 }
 

package/src/modular/buildClassicalOperationGroups.ts

@@ -1,7 +1,6 @@
 import { NameType } from "@azure-tools/rlc-common";
 import { SourceFile } from "ts-morph";
-import { importLroCoreDependencies } from "./buildLroFiles.js";
-import { importModels, importPagingDependencies } from "./buildOperations.js";
+import { importModels } from "./buildOperations.js";
 import { getClassicalOperation } from "./helpers/classicalOperationHelpers.js";
 import { getClassicalLayerPrefix } from "./helpers/namingHelpers.js";
 import {
@@ -56,16 +55,6 @@ export function buildClassicOperationFiles(
       );
       importApis(classicFile, client, codeModel, operationGroup);
       // We need to import the paging helpers and types explicitly because ts-morph may not be able to find them.
-      importPagingDependencies(
-        srcPath,
-        classicFile,
-        codeModel.project,
-        subfolder,
-        operationGroup.namespaceHierarchies.length
-      );
-      importLroCoreDependencies(classicFile);
-      classicFile.fixMissingImports();
-      classicFile.fixUnusedIdentifiers();
       classicOperationFiles.set(classicOperationFileName, classicFile);
     }
   }
@@ -109,18 +98,6 @@ export function buildClassicOperationFiles(
         // We SHOULD keep this because otherwise ts-morph will "helpfully" try to import models from the rest layer when we call fixMissingImports().
         importModels(srcPath, classicFile, codeModel.project, subfolder, layer);
         importApis(classicFile, client, codeModel, operationGroup, layer);
-        // We need to import the paging helpers and types explicitly because ts-morph may not be able to find them.
-        importPagingDependencies(
-          srcPath,
-          classicFile,
-          codeModel.project,
-          subfolder,
-          operationGroup.namespaceHierarchies.length
-        );
-        importLroCoreDependencies(classicFile);
-
-        classicFile.fixMissingImports();
-        classicFile.fixUnusedIdentifiers();
         classicOperationFiles.set(classicOperationFileName, classicFile);
       }
     }