@azure-tools/typespec-ts 0.45.1-alpha.20251105.1 → 0.46.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@azure-tools/typespec-ts",
-  "version": "0.45.1-alpha.20251105.1",
+  "version": "0.46.0",
   "description": "An experimental TypeSpec emitter for TypeScript RLC",
   "main": "dist/src/index.js",
   "type": "module",
@@ -77,7 +77,7 @@
     "@typespec/xml": "^0.75.0"
   },
   "dependencies": {
-    "@azure-tools/rlc-common": "0.45.1-alpha.20251105.1",
+    "@azure-tools/rlc-common": "^0.46.0",
     "fs-extra": "^11.1.0",
     "lodash": "^4.17.21",
     "prettier": "^3.3.3",

package/src/framework/hooks/binder.ts

@@ -303,7 +303,7 @@ class BinderImp implements Binder {
   }
 
   private cleanUnreferencedHelpers(sourceRoot: string) {
-    const usedHelperFiles = new Set<SourceFile>();
+    const usedHelperNames: string[] = [];
     for (const helper of this.staticHelpers.values()) {
       const sourceFile = helper[SourceFileSymbol];
       if (!sourceFile) {
@@ -315,16 +315,24 @@ class BinderImp implements Binder {
       const referencedHelper = this.references.get(refkey(helper));
 
       if (referencedHelper?.size) {
-        usedHelperFiles.add(sourceFile);
+        usedHelperNames.push(sourceFile.getBaseNameWithoutExtension());
       }
     }
 
+    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));
+    }
+
     this.project
       //normalizae the final path to adapt to different systems
       .getSourceFiles(
-        normalizePath(path.join(sourceRoot, "static-helpers/**/*.ts"))
+        normalizePath(path.join(sourceRoot, "static-helpers/**/*.*ts"))
       )
-      .filter((helperFile) => !usedHelperFiles.has(helperFile))
+      .filter(isFileUnused)
       .forEach((helperFile) => helperFile.delete());
   }
 }

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

@@ -187,7 +187,7 @@ async function traverseDirectory(
         } else if (
           fileStat.isFile() &&
           !file.endsWith(".d.ts") &&
-          file.endsWith(".ts")
+          /.*\..?ts$/.test(file)
         ) {
           const target = path.join(
             _targetStaticHelpersBaseDir,

package/src/modular/helpers/clientHelpers.ts

@@ -73,14 +73,15 @@ export function getClientParameters(
   const hasDefaultValue = (p: SdkParameter) =>
     p.clientDefaultValue || p.__raw?.defaultValue || p.type.kind === "constant";
   const isRequired = (p: SdkParameter) =>
-    !p.optional &&
-    ((!hasDefaultValue(p) &&
+    // Special case: when apiVersionAsRequired is true, apiVersion should always be considered required
+    (options.apiVersionAsRequired && p.isApiVersionParam) ||
+    (!p.optional &&
+      !hasDefaultValue(p) &&
       !(
         p.type.kind === "endpoint" &&
         p.type.templateArguments[0] &&
         hasDefaultValue(p.type.templateArguments[0])
-      )) ||
-      (options.apiVersionAsRequired && p.isApiVersionParam));
+      ));
   const isOptional = (p: SdkParameter) => p.optional || hasDefaultValue(p);
   const skipCredentials = (p: SdkParameter) => p.kind !== "credential";
   const skipMethodParam = (p: SdkParameter) => p.kind !== "method";
@@ -98,7 +99,6 @@ export function getClientParameters(
   const params = clientParams.filter((p) =>
     filters.every((filter) => !filter || filter(p))
   );
-
   return params;
 }
 

package/src/modular/helpers/operationHelpers.ts

@@ -8,6 +8,7 @@ import { NoTarget, Program } from "@typespec/compiler";
 import {
   PagingHelpers,
   PollingHelpers,
+  SerializationHelpers,
   UrlTemplateHelpers
 } from "../static-helpers-metadata.js";
 import {
@@ -472,11 +473,18 @@ export function getOperationFunction(
   };
 
   const statements: string[] = [];
-  statements.push(
-    `const result = await _${name}Send(${parameters
-      .map((p) => p.name)
-      .join(", ")});`
-  );
+
+  const parameterList = parameters.map((p) => p.name).join(", ");
+  // Special case for binary-only bodies: use helper to call streaming methods so that Core doesn't poison the response body by
+  // doing a UTF-8 decode on the raw bytes.
+  if (response?.type?.kind === "bytes" && response.type.encode === "bytes") {
+    statements.push(`const streamableMethod = _${name}Send(${parameterList});`);
+    statements.push(
+      `const result = await ${resolveReference(SerializationHelpers.getBinaryResponse)}(streamableMethod);`
+    );
+  } else {
+    statements.push(`const result = await _${name}Send(${parameterList});`);
+  }
   statements.push(`return _${name}Deserialize(result);`);
 
   return {
@@ -1577,7 +1585,7 @@ export function getExpectedStatuses(operation: ServiceOperation): string {
   let statusCodes = operation.operation.responses.map((x) => x.statusCodes);
   // LROs may call the same path but with GET to get the operation status.
   if (isLroOnlyOperation(operation) && operation.operation.verb !== "get") {
-    statusCodes = Array.from(new Set([...statusCodes, 200, 202]));
+    statusCodes = Array.from(new Set([...statusCodes, 200, 201, 202]));
   }
 
   return `[${statusCodes.map((x) => `"${x}"`).join(", ")}]`;

package/src/modular/static-helpers-metadata.ts

@@ -28,6 +28,11 @@ export const SerializationHelpers = {
     kind: "function",
     name: "serializeRecord",
     location: "serialization/serialize-record.ts"
+  },
+  getBinaryResponse: {
+    kind: "function",
+    name: "getBinaryResponse",
+    location: "serialization/get-binary-response.ts"
   }
 } as const;
 

package/static/static-helpers/serialization/get-binary-response-browser.mts

@@ -0,0 +1,20 @@
+import { HttpResponse, StreamableMethod } from "@azure-rest/core-client";
+
+/**
+ * Gets a response type representing the given streamable response, using the stream methods
+ * to bypass Core's default response handling. This works around an issue where binary bodies in Core
+ * are coerced into UTF-8, regardless of whether the body is valid UTF-8 or not.
+ */
+export async function getBinaryResponse(streamableMethod: StreamableMethod): Promise<HttpResponse & { body?: Uint8Array }> {
+  const response = await streamableMethod.asBrowserStream();
+
+  if (response.body === undefined) {
+    return response as HttpResponse & { body?: Uint8Array };
+  }
+
+  const arrayBuffer = await new Response(response.body).arrayBuffer();
+  return {
+    ...response,
+    body: new Uint8Array(arrayBuffer),
+  };
+}

package/static/static-helpers/serialization/get-binary-response.ts

@@ -0,0 +1,25 @@
+import { HttpResponse, StreamableMethod } from "@azure-rest/core-client";
+import { Buffer } from "node:buffer";
+
+/**
+ * Gets a response type representing the given streamable response, using the stream methods
+ * to bypass Core's default response handling. This works around an issue where binary bodies in Core
+ * are coerced into UTF-8, regardless of whether the body is valid UTF-8 or not.
+ */
+export async function getBinaryResponse(
+  streamableMethod: StreamableMethod
+): Promise<HttpResponse & { body?: Uint8Array }> {
+  const response = await streamableMethod.asNodeStream();
+  if (response.body === undefined) {
+    return response as HttpResponse & { body?: Uint8Array };
+  }
+  const bufs: Buffer[] = [];
+  for await (const buf of response.body) {
+    bufs.push(Buffer.isBuffer(buf) ? buf : Buffer.from(buf));
+  }
+
+  return {
+    ...response,
+    body: Buffer.concat(bufs)
+  };
+}