@azure-tools/typespec-ts 0.13.4 → 0.14.0

package/src/modular/emitModels.ts

@@ -1,6 +1,7 @@
 import { Project, SourceFile } from "ts-morph";
 import { getType } from "./helpers/typeHelpers.js";
 import { ModularCodeModel, Type } from "./modularCodeModel.js";
+import * as path from "path";
 
 /**
  * This function creates the file containing all the models defined in TypeSpec
@@ -8,9 +9,12 @@ import { ModularCodeModel, Type } from "./modularCodeModel.js";
 export function buildModels(
   codeModel: ModularCodeModel,
   project: Project,
-  srcPath: string = "src"
+  srcPath: string = "src",
+  subfolder: string = ""
 ): SourceFile {
-  const modelsFile = project.createSourceFile(`${srcPath}/src/api/models.ts`);
+  const modelsFile = project.createSourceFile(
+    path.join(`${srcPath}/src/`, subfolder, `models/models.ts`)
+  );
 
   // We are generating both models and enums here
   const coreClientTypes = new Set<string>();

package/src/modular/helpers/clientHelpers.ts

@@ -14,7 +14,11 @@ export function getClientParameters(
 
   const params: OptionalKind<ParameterDeclarationStructure>[] = [
     ...parameters
-      .filter((p) => p.type.type !== "constant")
+      .filter(
+        (p) =>
+          p.type.type !== "constant" &&
+          (p.clientDefaultValue === null || p.clientDefaultValue === undefined)
+      )
       .map<OptionalKind<ParameterDeclarationStructure>>((p) => {
         return {
           name: p.clientName,

package/src/modular/helpers/namingHelpers.ts

@@ -38,6 +38,7 @@ export function getOperationName(
 export function isReservedName(name: string, nameType: NameType): boolean {
   return ReservedModelNames.some(
     (reservedName) =>
-      reservedName.name === name && reservedName.reservedFor.includes(nameType)
+      reservedName.name === name.toLowerCase() &&
+      reservedName.reservedFor.includes(nameType)
   );
 }

package/src/modular/helpers/operationHelpers.ts

@@ -12,24 +12,41 @@ import {
   Type
 } from "../modularCodeModel.js";
 import { buildType } from "./typeHelpers.js";
+import {
+  NameType,
+  OperationResponse,
+  getResponseBaseName,
+  getResponseTypeName,
+  normalizeName
+} from "@azure-tools/rlc-common";
 import { getOperationName } from "./namingHelpers.js";
 import { getFixmeForMultilineDocs } from "./fixmeHelpers.js";
 
-function getRLCResponseType(operation: Operation) {
-  const { name } = getOperationName(operation, { casing: "pascal" });
-  const statusCodes: (string | number)[] = Array.from(
-    new Set(operation.responses.flatMap((r) => r.statusCodes)).values()
-  );
-
-  statusCodes.push("Default");
-
-  return statusCodes.map((s) => `${name}${s}Response`).join(" | ");
+function getRLCResponseType(rlcResponse?: OperationResponse) {
+  if (!rlcResponse?.responses) {
+    return;
+  }
+  return rlcResponse?.responses
+    .map((resp) => {
+      const baseResponseName = getResponseBaseName(
+        rlcResponse.operationGroup,
+        rlcResponse.operationName,
+        resp.statusCode
+      );
+      // Get the information to build the Response Interface
+      return resp.predefinedName ?? getResponseTypeName(baseResponseName);
+    })
+    .join(" | ");
 }
 
 export function getSendPrivateFunction(
-  operation: Operation
+  operation: Operation,
+  clientType: string
 ): OptionalKind<FunctionDeclarationStructure> {
-  const parameters = getOperationSignatureParameters(operation);
+  if (operation.name === "uploadTestFile") {
+    operation;
+  }
+  const parameters = getOperationSignatureParameters(operation, clientType);
   const { name } = getOperationName(operation);
 
   const functionStatement: OptionalKind<FunctionDeclarationStructure> = {
@@ -37,7 +54,7 @@ export function getSendPrivateFunction(
     isExported: true,
     name: `_${name}Send`,
     parameters,
-    returnType: `StreamableMethod<${getRLCResponseType(operation)}>`
+    returnType: `StreamableMethod<${getRLCResponseType(operation.rlcResponse)}>`
   };
 
   const operationPath = operation.url;
@@ -47,7 +64,7 @@ export function getSendPrivateFunction(
   statements.push(
     `return context.path("${operationPath}", ${getPathParameters(
       operation
-    )}).${operationMethod}({allowInsecureConnection: options.requestOptions?.allowInsecureConnection, skipUrlEncoding: options.requestOptions?.skipUrlEncoding, ${getRequestParameters(
+    )}).${operationMethod}({...operationOptionsToRequestParameters(options), ${getRequestParameters(
       operation
     )}});`
   );
@@ -59,22 +76,35 @@ export function getSendPrivateFunction(
 }
 
 export function getDeserializePrivateFunction(
-  operation: Operation
+  operation: Operation,
+  needSubClient: boolean,
+  needUnexpectedHelper: boolean
 ): OptionalKind<FunctionDeclarationStructure> {
   const { name } = getOperationName(operation);
 
-  const parameters: OptionalKind<ParameterDeclarationStructure>[] = [
+  let parameters: OptionalKind<ParameterDeclarationStructure>[] = [
     {
       name: "result",
-      type: getRLCResponseType(operation)
+      type: getRLCResponseType(operation.rlcResponse)
     }
   ];
 
   // TODO: Support operation overloads
   const response = operation.responses[0]!;
-  const returnType = response?.type?.type
-    ? buildType(response.type.name, response.type)
-    : { name: "", type: "void" };
+  let returnType;
+  if (response?.type?.type) {
+    returnType = buildType(response.type.name, response.type);
+  } else {
+    if (!needUnexpectedHelper) {
+      parameters = [
+        {
+          name: "_result",
+          type: getRLCResponseType(operation.rlcResponse)
+        }
+      ];
+    }
+    returnType = { name: "", type: "void" };
+  }
 
   const functionStatement: OptionalKind<FunctionDeclarationStructure> = {
     isAsync: true,
@@ -84,7 +114,13 @@ export function getDeserializePrivateFunction(
     returnType: `Promise<${returnType.type}>`
   };
   const statements: string[] = [];
-  statements.push(`if(isUnexpected(result)){`, "throw result.body", "}");
+  if (needUnexpectedHelper) {
+    statements.push(
+      `if(${needSubClient ? "UnexpectedHelper." : ""}isUnexpected(result)){`,
+      "throw result.body",
+      "}"
+    );
+  }
 
   if (response?.type?.type === "any") {
     statements.push(`return result.body`);
@@ -110,7 +146,8 @@ export function getDeserializePrivateFunction(
 }
 
 function getOperationSignatureParameters(
-  operation: Operation
+  operation: Operation,
+  clientType: string
 ): OptionalKind<ParameterDeclarationStructure>[] {
   const optionsType = getOperationOptionsName(operation);
   const parameters: Map<
@@ -129,6 +166,14 @@ function getOperationSignatureParameters(
       bodyArray.clientName,
       buildType(bodyArray.clientName, bodyArray.type)
     );
+  } else if (operation.bodyParameter?.type.type === "byte-array") {
+    parameters.set(
+      operation.bodyParameter.clientName,
+      buildType(
+        operation.bodyParameter.clientName,
+        operation.bodyParameter.type
+      )
+    );
   }
 
   operation.parameters
@@ -145,7 +190,7 @@ function getOperationSignatureParameters(
     });
 
   // Add context as the first parameter
-  const contextParam = { name: "context", type: "Client" };
+  const contextParam = { name: "context", type: clientType };
 
   // Add the options parameter
   const optionsParam = {
@@ -163,11 +208,12 @@ function getOperationSignatureParameters(
  * This operation builds and returns the function declaration for an operation.
  */
 export function getOperationFunction(
-  operation: Operation
+  operation: Operation,
+  clientType: string
 ): OptionalKind<FunctionDeclarationStructure> {
   // Extract required parameters
   const parameters: OptionalKind<ParameterDeclarationStructure>[] =
-    getOperationSignatureParameters(operation);
+    getOperationSignatureParameters(operation, clientType);
 
   // TODO: Support operation overloads
   const response = operation.responses[0]!;
@@ -180,7 +226,7 @@ export function getOperationFunction(
     docs: [operation.description, ...getFixmeForMultilineDocs(fixme)],
     isAsync: true,
     isExported: true,
-    name: name,
+    name: normalizeName(operation.name, NameType.Operation, true),
     parameters,
     returnType: `Promise<${returnType.type}>`
   };
@@ -241,11 +287,11 @@ function getRequestParameters(operation: Operation): string {
     paramStr = `${getContentTypeValue(contentTypeParameter)},`;
   }
 
-  paramStr = `${paramStr}\nheaders: {${
-    parametersImplementation.header.length
-      ? parametersImplementation.header.join(",\n") + ","
-      : ""
-  } ...options.requestOptions?.headers},`;
+  if (parametersImplementation.header.length) {
+    paramStr = `${paramStr}\nheaders: {${
+      parametersImplementation.header.join(",\n") + ","
+    },`;
+  }
 
   if (parametersImplementation.query.length) {
     paramStr = `${paramStr}\nqueryParameters: {${parametersImplementation.query.join(
@@ -280,6 +326,10 @@ function buildBodyParameter(bodyParameter: BodyParameter | undefined) {
     return `\nbody: ${bodyParameter.clientName},`;
   }
 
+  if (bodyParameter.type.type === "byte-array") {
+    return `\nbody: ${bodyParameter.clientName},`;
+  }
+
   return "";
 }
 
@@ -324,7 +374,7 @@ function getContentTypeValue(param: Parameter | Property) {
   }
 
   if (defaultValue) {
-    return `contentType: (options.${param.clientName} as any) ?? "${defaultValue}"`;
+    return `contentType: options.${param.clientName} as any ?? "${defaultValue}"`;
   } else {
     return `contentType: options.${param.clientName}`;
   }
@@ -424,18 +474,19 @@ function getPathParameters(operation: Operation) {
   for (const param of operation.parameters) {
     if (param.location === "path") {
       if (!param.optional) {
-        pathParams = `${pathParams} ${param.clientName},`;
+        pathParams += `${pathParams !== "" ? "," : ""} ${param.clientName}`;
         continue;
       }
 
       const defaultValue = getDefaultValue(param);
 
-      pathParams = `${pathParams}, options.${param.clientName}`;
+      pathParams += `${pathParams !== "" ? "," : ""} options.${
+        param.clientName
+      }`;
 
       if (defaultValue) {
-        pathParams = ` ?? "${defaultValue}"`;
+        pathParams += ` ?? "${defaultValue}"`;
       }
-      pathParams = `${pathParams},`;
     }
   }
 
@@ -511,6 +562,8 @@ function deserializeResponseValue(type: Type, restValue: string): string {
   switch (type.type) {
     case "datetime":
       return `new Date(${restValue} ?? "")`;
+    case "byte-array":
+      return `Buffer.from(${restValue} ?? "")`;
     case "list":
       if (type.elementType?.type === "model") {
         return `(${restValue} ?? []).map(p => ({${getResponseMapping(

package/src/modular/modularCodeModel.ts

@@ -1,4 +1,4 @@
-import { RLCOptions } from "@azure-tools/rlc-common";
+import { OperationResponse, RLCOptions } from "@azure-tools/rlc-common";
 
 export interface ModularCodeModel {
   options: RLCOptions;
@@ -95,6 +95,7 @@ export interface Client {
   operationGroups: OperationGroup[];
   url: string;
   apiVersions: any[];
+  rlcClientName: string;
 }
 
 export type ParameterLocation =
@@ -151,4 +152,5 @@ export interface Operation {
   itemName?: string;
   continuationTokenName?: string;
   addedOn?: string;
+  rlcResponse?: OperationResponse;
 }

package/src/transform/transform.ts

@@ -38,19 +38,23 @@ import { transformRLCOptions } from "./transfromRLCOptions.js";
 import { transformApiVersionInfo } from "./transformApiVersionInfo.js";
 import { getClientLroOverload } from "../utils/operationUtil.js";
 
+export interface RLCSdkContext extends SdkContext {
+  options?: RLCOptions;
+}
+
 export async function transformRLCModel(
   program: Program,
   emitterOptions: RLCOptions,
   client: SdkClient,
   emitterOutputDir: string,
-  dpgContext: SdkContext
+  dpgContext: RLCSdkContext
 ): Promise<RLCModel> {
   const options: RLCOptions = transformRLCOptions(
-    program,
     emitterOptions,
     emitterOutputDir,
     dpgContext
   );
+  dpgContext.options = options;
   const srcPath = join(
     emitterOutputDir ?? "",
     "src",
@@ -74,31 +78,20 @@ export async function transformRLCModel(
   const schemas: Schema[] = transformSchemas(program, client, dpgContext);
 
   const responses: OperationResponse[] = transformToResponseTypes(
-    program,
     importSet,
     client,
     dpgContext
   );
   const parameters: OperationParameter[] = transformToParameterTypes(
-    program,
     importSet,
     client,
     dpgContext
   );
-  const helperDetails = transformHelperFunctionDetails(
-    program,
-    client,
-    dpgContext
-  );
+  const helperDetails = transformHelperFunctionDetails(client, dpgContext);
   // Enrich client-level annotation detail
   helperDetails.clientLroOverload = getClientLroOverload(paths);
   const urlInfo = transformUrlInfo(program, dpgContext);
-  const apiVersionInfo = transformApiVersionInfo(
-    client,
-    program,
-    dpgContext,
-    urlInfo
-  );
+  const apiVersionInfo = transformApiVersionInfo(client, dpgContext, urlInfo);
   return {
     srcPath,
     libraryName,
@@ -137,7 +130,6 @@ export function transformUrlInfo(
         }
 
         const schema = getSchemaForType(
-          program,
           dpgContext,
           type,
           [SchemaContext.Exception, SchemaContext.Input],
@@ -151,11 +143,7 @@ export function transformUrlInfo(
             (getDoc(program, property) &&
               getFormattedPropertyDoc(program, property, schema, " ")) ??
             getFormattedPropertyDoc(program, type, schema, " " /* sperator*/),
-          value: predictDefaultValue(
-            program,
-            dpgContext,
-            host?.[0]?.parameters.get(key)
-          )
+          value: predictDefaultValue(dpgContext, host?.[0]?.parameters.get(key))
         });
       }
     }

package/src/transform/transformApiVersionInfo.ts

@@ -22,10 +22,10 @@ import {
 
 export function transformApiVersionInfo(
   client: SdkClient,
-  program: Program,
   dpgContext: SdkContext,
   urlInfo?: UrlInfo
 ): ApiVersionInfo | undefined {
+  const program = dpgContext.program;
   const queryVersionDetail = getOperationQueryApiVersion(
     client,
     program,
@@ -77,7 +77,6 @@ function getOperationQueryApiVersion(
       );
       params.map((p) => {
         const type = getSchemaForType(
-          program,
           dpgContext,
           p.param.type,
           [SchemaContext.Exception, SchemaContext.Input],
@@ -104,7 +103,6 @@ function getOperationQueryApiVersion(
     );
     params.map((p) => {
       const type = getSchemaForType(
-        program,
         dpgContext,
         p.param.type,
         [SchemaContext.Exception, SchemaContext.Input],

package/src/transform/transformHelperFunctionDetails.ts

@@ -16,10 +16,10 @@ import {
 import { getSpecialSerializeInfo } from "./transformParameters.js";
 
 export function transformHelperFunctionDetails(
-  program: Program,
   client: SdkClient,
   dpgContext: SdkContext
 ): HelperFunctionDetails {
+  const program = dpgContext.program;
   // Extract paged metadata from Azure.Core.Page
   const annotationDetails = {
     hasLongRunning: hasPollingOperations(program, client, dpgContext)