@azure-tools/typespec-ts 0.50.2 → 0.50.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@azure-tools/typespec-ts",
-  "version": "0.50.2",
+  "version": "0.50.3",
   "description": "An experimental TypeSpec emitter for TypeScript RLC",
   "main": "dist/src/index.js",
   "type": "module",
@@ -73,7 +73,7 @@
     "@typespec/xml": "^0.79.0"
   },
   "dependencies": {
-    "@azure-tools/rlc-common": "^0.50.2",
+    "@azure-tools/rlc-common": "^0.50.3",
     "fast-xml-parser": "^4.5.0",
     "fs-extra": "^11.1.0",
     "lodash": "^4.17.21",

package/src/framework/hooks/binder.ts

@@ -42,7 +42,7 @@ export interface Binder {
     sourceFile: SourceFile
   ): string;
   resolveReference(refkey: unknown): string;
-  resolveAllReferences(sourceRoot: string): void;
+  resolveAllReferences(sourceRoot: string, testRoot?: string): void;
 }
 
 const PLACEHOLDER_PREFIX = "__PLACEHOLDER_";
@@ -216,7 +216,7 @@ class BinderImp implements Binder {
   /**
    * Applies all tracked imports to their respective source files.
    */
-  resolveAllReferences(sourceRoot: string): void {
+  resolveAllReferences(sourceRoot: string, testRoot?: string): void {
     this.project.getSourceFiles().map((file) => {
       this.resolveDeclarationReferences(file);
       this.resolveDependencyReferences(file);
@@ -232,7 +232,7 @@ class BinderImp implements Binder {
       }
     });
 
-    this.cleanUnreferencedHelpers(sourceRoot);
+    this.cleanUnreferencedHelpers(sourceRoot, testRoot);
   }
 
   private resolveDependencyReferences(file: SourceFile) {
@@ -292,7 +292,7 @@ class BinderImp implements Binder {
     this.references.get(refkey)!.add(sourceFile);
   }
 
-  private cleanUnreferencedHelpers(sourceRoot: string) {
+  private cleanUnreferencedHelpers(sourceRoot: string, testRoot?: string) {
     const usedHelperNames: string[] = [];
     for (const helper of this.staticHelpers.values()) {
       const sourceFile = helper[SourceFileSymbol];
@@ -311,7 +311,6 @@ class BinderImp implements Binder {
 
     function isFileUnused(file: SourceFile) {
       const name = file.getBaseNameWithoutExtension();
-
       // If one of the used helpers' name is a prefix of this file, the file likely represents a platform-specific implementation of the helper
       // so it should be marked as used even if the file has no direct references.
       return !usedHelperNames.some((s) => name.startsWith(s));
@@ -324,6 +323,17 @@ class BinderImp implements Binder {
       )
       .filter(isFileUnused)
       .forEach((helperFile) => helperFile.delete());
+
+    if (!testRoot) {
+      return;
+    }
+    this.project
+      //normalizae the final path to adapt to different systems
+      .getSourceFiles(
+        normalizePath(path.join(testRoot, "test/generated/util/**/*.*ts"))
+      )
+      .filter(isFileUnused)
+      .forEach((helperFile) => helperFile.delete());
   }
 }
 

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

@@ -37,12 +37,21 @@ export function isStaticHelperMetadata(
 
 export type StaticHelpers = Record<string, StaticHelperMetadata>;
 
-const DEFAULT_STATIC_HELPERS_PATH = "static/static-helpers";
+const DEFAULT_SOURCES_STATIC_HELPERS_PATH = "static/static-helpers";
+const DEFAULT_SOURCES_TESTING_HELPERS_PATH = "static/test-helpers";
 
 export interface LoadStaticHelpersOptions extends Partial<ModularEmitterOptions> {
   helpersAssetDirectory?: string;
   sourcesDir?: string;
+  rootDir?: string;
   program?: Program;
+  /** When true, also load test helpers from static/test-helpers/ into test/generated/util/ */
+  loadTestHelpers?: boolean;
+}
+
+interface FileMetadata {
+  source: string;
+  target: string;
 }
 
 export async function loadStaticHelpers(
@@ -50,64 +59,85 @@ export async function loadStaticHelpers(
   helpers: StaticHelpers,
   options: LoadStaticHelpersOptions = {}
 ): Promise<Map<string, StaticHelperMetadata>> {
-  const sourcesDir = options.sourcesDir ?? "";
   const helpersMap = new Map<string, StaticHelperMetadata>();
+  // Load static helpers used in sources code
   const defaultStaticHelpersPath = path.join(
     resolveProjectRoot(),
-    DEFAULT_STATIC_HELPERS_PATH
+    DEFAULT_SOURCES_STATIC_HELPERS_PATH
   );
-  const files = await traverseDirectory(
+  const filesInSources = await traverseDirectory(
     options.helpersAssetDirectory ?? defaultStaticHelpersPath,
     options.program
   );
+  await loadFiles(filesInSources, options.sourcesDir ?? "");
+  // Load static helpers used in testing code (only when loadTestHelpers is enabled)
+  if (
+    options.loadTestHelpers ??
+    (options.options?.generateTest &&
+      isAzurePackage({ options: options.options }))
+  ) {
+    const defaultTestingHelpersPath = path.join(
+      resolveProjectRoot(),
+      DEFAULT_SOURCES_TESTING_HELPERS_PATH
+    );
+    const filesInTestings = await traverseDirectory(
+      defaultTestingHelpersPath,
+      options.program,
+      [],
+      "",
+      "test/generated/util"
+    );
+    await loadFiles(filesInTestings, options.rootDir ?? "");
+  }
+  return assertAllHelpersLoadedPresent(helpersMap);
 
-  for (const file of files) {
-    const targetPath = path.join(sourcesDir, file.target);
-    const contents = await readFile(file.source, "utf-8");
-    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");
+  async function loadFiles(files: FileMetadata[], generateDir: string) {
+    for (const file of files) {
+      const targetPath = path.join(generateDir, file.target);
+      const contents = await readFile(file.source, "utf-8");
+      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");
+          }
         }
-        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)) {
+          continue;
         }
-      }
-    });
 
-    for (const entry of Object.values(helpers)) {
-      if (!addedFile.getFilePath().endsWith(entry.location)) {
-        continue;
-      }
+        const declaration = getDeclarationByMetadata(addedFile, entry);
+        if (!declaration) {
+          throw new Error(
+            `Declaration ${
+              entry.name
+            } not found in file ${addedFile.getFilePath()}\n This is an Emitter bug, make sure that the map of static helpers passed to loadStaticHelpers matches what is in the file.`
+          );
+        }
 
-      const declaration = getDeclarationByMetadata(addedFile, entry);
-      if (!declaration) {
-        throw new Error(
-          `Declaration ${
-            entry.name
-          } not found in file ${addedFile.getFilePath()}\n This is an Emitter bug, make sure that the map of static helpers passed to loadStaticHelpers matches what is in the file.`
-        );
+        entry[SourceFileSymbol] = addedFile;
+        helpersMap.set(refkey(entry), entry);
       }
-
-      entry[SourceFileSymbol] = addedFile;
-      helpersMap.set(refkey(entry), entry);
     }
   }
-
-  return assertAllHelpersLoadedPresent(helpersMap);
 }
 
 function assertAllHelpersLoadedPresent(
@@ -166,7 +196,8 @@ async function traverseDirectory(
   directory: string,
   program?: Program,
   result: { source: string; target: string }[] = [],
-  relativePath: string = ""
+  relativePath: string = "",
+  targetBaseDir: string = _targetStaticHelpersBaseDir
 ): Promise<{ source: string; target: string }[]> {
   try {
     const files = await readdir(directory);
@@ -181,18 +212,15 @@ async function traverseDirectory(
             filePath,
             program,
             result,
-            path.join(relativePath, file)
+            path.join(relativePath, file),
+            targetBaseDir
           );
         } else if (
           fileStat.isFile() &&
           !file.endsWith(".d.ts") &&
           /.*\..?ts$/.test(file)
         ) {
-          const target = path.join(
-            _targetStaticHelpersBaseDir,
-            relativePath,
-            file
-          );
+          const target = path.join(targetBaseDir, relativePath, file);
           result.push({ source: filePath, target });
         }
       })

package/src/index.ts

@@ -6,13 +6,15 @@ import {
   AzureCoreDependencies,
   AzureIdentityDependencies,
   AzurePollingDependencies,
-  DefaultCoreDependencies
+  DefaultCoreDependencies,
+  AzureTestDependencies
 } from "./modular/external-dependencies.js";
 import { clearDirectory } from "./utils/fileSystemUtils.js";
 import { EmitContext, Program } from "@typespec/compiler";
 import { GenerationDirDetail, SdkContext } from "./utils/interfaces.js";
 import {
   CloudSettingHelpers,
+  CreateRecorderHelpers,
   MultipartHelpers,
   PagingHelpers,
   PollingHelpers,
@@ -91,7 +93,7 @@ import {
 } from "@azure-tools/typespec-client-generator-core";
 import { transformModularEmitterOptions } from "./modular/buildModularOptions.js";
 import { emitLoggerFile } from "./modular/emitLoggerFile.js";
-import { emitTypes } from "./modular/emitModels.js";
+import { emitTypes, emitNonModelResponseTypes } from "./modular/emitModels.js";
 import { existsSync } from "fs";
 import { getModuleExports } from "./modular/buildProjectFiles.js";
 import {
@@ -107,6 +109,7 @@ import { provideSdkTypes } from "./framework/hooks/sdkTypes.js";
 import { transformRLCModel } from "./transform/transform.js";
 import { transformRLCOptions } from "./transform/transfromRLCOptions.js";
 import { emitSamples } from "./modular/emitSamples.js";
+import { emitTests } from "./modular/emitTests.js";
 import { generateCrossLanguageDefinitionFile } from "./utils/crossLanguageDef.js";
 import { getClassicalClientName } from "./modular/helpers/namingHelpers.js";
 
@@ -148,10 +151,12 @@ export async function $onEmit(context: EmitContext) {
       ...MultipartHelpers,
       ...CloudSettingHelpers,
       ...XmlHelpers,
+      ...(rlcOptions.generateTest ? CreateRecorderHelpers : {}),
       ...(rlcOptions.enableStorageCompat ? StorageCompatHelpers : {})
     },
     {
       sourcesDir: dpgContext.generationPathDetail?.modularSourcesDir,
+      rootDir: dpgContext.generationPathDetail?.rootDir,
       options: rlcOptions,
       program
     }
@@ -160,7 +165,8 @@ export async function $onEmit(context: EmitContext) {
     ? {
         ...AzurePollingDependencies,
         ...AzureCoreDependencies,
-        ...AzureIdentityDependencies
+        ...AzureIdentityDependencies,
+        ...AzureTestDependencies
       }
     : { ...DefaultCoreDependencies };
   const binder = provideBinder(outputProject, {
@@ -327,6 +333,7 @@ export async function $onEmit(context: EmitContext) {
     );
 
     emitTypes(dpgContext, { sourceRoot: modularSourcesRoot });
+    emitNonModelResponseTypes(dpgContext, { sourceRoot: modularSourcesRoot });
     buildSubpathIndexFile(modularEmitterOptions, "models", undefined, {
       recursive: true
     });
@@ -381,7 +388,15 @@ export async function $onEmit(context: EmitContext) {
       }
     }
 
-    binder.resolveAllReferences(modularSourcesRoot);
+    // Enable modular test generation when generateTest is true
+    if (dpgContext.rlcOptions?.generateTest === true) {
+      await emitTests(dpgContext);
+    }
+
+    binder.resolveAllReferences(
+      modularSourcesRoot,
+      dpgContext.generationPathDetail?.rootDir
+    );
     if (program.compilerOptions.noEmit || program.hasError()) {
       return;
     }
@@ -453,7 +468,7 @@ export async function $onEmit(context: EmitContext) {
       "test"
     );
     const hasTestFolder = await existsSync(existingTestFolderPath);
-    if (option.azureSdkForJs && option.generateTest === undefined) {
+    if (option.generateTest === undefined) {
       if (hasTestFolder) {
         option.generateTest = false;
       } else {
@@ -535,7 +550,7 @@ export async function $onEmit(context: EmitContext) {
       }
 
       // TODO: need support snippets generation for multi-client cases. https://github.com/Azure/autorest.typescript/issues/3048
-      if (option.generateTest && isAzureFlavor) {
+      if (option.generateTest) {
         for (const subClient of dpgContext.sdkPackage.clients) {
           commonBuilders.push((model) =>
             buildSnippets(model, subClient.name, option.azureSdkForJs)
@@ -632,7 +647,7 @@ export async function $onEmit(context: EmitContext) {
     }
 
     // Generate test relevant files
-    if (option.generateTest && isAzureFlavor && !hasTestFolder) {
+    if (option.generateTest && !hasTestFolder) {
       await emitContentByBuilder(
         program,
         [buildRecordedClientFile, buildSampleTest],

package/src/lib.ts

@@ -79,6 +79,13 @@ export interface EmitterOptions {
   //TODO should remove this after finish the release tool test
   "should-use-pnpm-dep"?: boolean;
   "ignore-nullable-on-optional"?: boolean;
+  /**
+   * When set to true (default for Azure services), non-model return types (arrays, scalars, enums,
+   * bytes with binary content type) will be wrapped in an XxxResponse type to maintain backward
+   * compatibility with HLC-generated code during TypeSpec migration.
+   * Set to false to return the non-model types directly.
+   */
+  "wrap-non-model-return"?: boolean;
   /**
    * When enabled, every regular (non-LRO, non-paging) operation return type is augmented with a
    * `_response` property containing `rawResponse`, `parsedBody`, and `parsedHeaders`.
@@ -370,6 +377,12 @@ export const RLCOptionsSchema: JSONSchemaType<EmitterOptions> = {
       description:
         "If an optional property is also marked as nullable, it will be treated as just optional. Defaults to `true` for Azure services."
     },
+    "wrap-non-model-return": {
+      type: "boolean",
+      nullable: true,
+      description:
+        "When set to true (default for Azure services), non-model return types (arrays, scalars, enums, bytes with binary content type) will be wrapped in an XxxResponse type for HLC backward compatibility during TypeSpec migration."
+    },
     "enable-storage-compat": {
       type: "boolean",
       nullable: true,

package/src/modular/buildOperations.ts

@@ -92,7 +92,7 @@ export function buildOperationFiles(
       );
       const deserializeOperationDeclaration = getDeserializePrivateFunction(
         dpgContext,
-        op
+        [prefixes, op]
       );
       const deserializeHeadersDeclaration =
         getDeserializeHeadersPrivateFunction(dpgContext, op);
@@ -108,6 +108,7 @@ export function buildOperationFiles(
       if (deserializeExceptionHeadersDeclaration) {
         functionsToAdd.push(deserializeExceptionHeadersDeclaration);
       }
+
       operationGroupFile.addFunctions(functionsToAdd);
       addDeclaration(
         operationGroupFile,

package/src/modular/emitModels.ts

@@ -79,9 +79,15 @@ import {
   flattenPropertyModelMap,
   getAllOperationsFromClient
 } from "../framework/hooks/sdkTypes.js";
-import { getAllAncestors } from "./helpers/operationHelpers.js";
-import { getAllProperties } from "./helpers/operationHelpers.js";
+import {
+  getAllAncestors,
+  getAllProperties,
+  buildNonModelResponseTypeDeclaration,
+  checkWrapNonModelReturn
+} from "./helpers/operationHelpers.js";
 import { getDirectSubtypes } from "./helpers/typeHelpers.js";
+import { getClientHierarchyMap } from "../utils/clientUtils.js";
+import { getMethodHierarchiesMap } from "../utils/operationUtil.js";
 
 type InterfaceStructure = OptionalKind<InterfaceDeclarationStructure> & {
   extends?: string[];
@@ -164,6 +170,45 @@ export function emitTypes(
   return result;
 }
 
+/**
+ * Emits the XxxResponse wrapper type aliases for non-model return operations
+ * into the models.ts file, so they are exported publicly as part of the models API surface.
+ * This must be called after emitTypes() and before buildSubpathIndexFile("models").
+ */
+export function emitNonModelResponseTypes(
+  context: SdkContext,
+  { sourceRoot }: { sourceRoot: string }
+) {
+  const outputProject = useContext("outputProject");
+  const clientMap = getClientHierarchyMap(context);
+
+  const filepath = getModelsPath(sourceRoot);
+  let modelsFile = outputProject.getSourceFile(filepath);
+
+  for (const subClient of clientMap) {
+    const methodHierarchies = getMethodHierarchiesMap(context, subClient[1]);
+    for (const [prefixKey, operations] of methodHierarchies) {
+      const prefixes = prefixKey.split("/");
+      for (const op of operations) {
+        const { shouldWrap, isBinary } = checkWrapNonModelReturn(context, op);
+        if (!shouldWrap) {
+          continue;
+        }
+        if (!modelsFile) {
+          modelsFile = outputProject.createSourceFile(filepath);
+        }
+        const method: [string[], typeof op] = [prefixes, op];
+        const typeAlias = buildNonModelResponseTypeDeclaration(
+          context,
+          method,
+          isBinary
+        );
+        addDeclaration(modelsFile, typeAlias, refkey(op, "response"));
+      }
+    }
+  }
+}
+
 function emitType(context: SdkContext, type: SdkType, sourceFile: SourceFile) {
   if (type.kind === "model") {
     if (isAzureCoreErrorType(context.program, type.__raw)) {

package/src/modular/emitSamples.ts

@@ -627,9 +627,15 @@ function getParameterValue(
           propRetValue =
             paramValue.length > 2 ? paramValue.slice(1, -1) : undefined;
         } else {
+          // Don't propagate enableFlatten:false to deeper levels — it's only
+          // meant to block consecutive (transition) flatten at the direct child
+          // level.  Non-flatten properties should recurse with default behavior
+          // so that independent inner flattens at deeper levels still work.
+          const childOptions =
+            options?.overrides?.enableFlatten === false ? undefined : options;
           propRetValue =
             `"${mapper.get(propName) ?? propName}": ` +
-            getParameterValue(context, propValue, options);
+            getParameterValue(context, propValue, childOptions);
         }
         if (propRetValue) values.push(propRetValue);
       }