@azure-tools/typespec-ts 0.28.0 → 0.29.0-alpha.20240531.1

package/src/modular/emitModels.ts

@@ -19,24 +19,48 @@ function isAzureCoreErrorSdkType(t: Type) {
     ["error", "errormodel", "innererror", "errorresponse"].includes(
       t.name.toLowerCase()
     ) &&
-    t.isCoreErrorType === true
+    t.coreTypeInfo === "ErrorType"
   );
 }
 
+function isAzureCoreLroSdkType(t: Type) {
+  return (
+    t.name &&
+    ["operationstate"].includes(t.name.toLowerCase()) &&
+    t.coreTypeInfo === "LroType"
+  );
+}
+
+function isAnonymousModel(t: Type) {
+  return t.type === "model" && t.name === "";
+}
+
+export function isModelWithAdditionalProperties(t: Type) {
+  return t.type === "dict" && t.name !== "Record";
+}
+
 function getCoreClientErrorType(name: string, coreClientTypes: Set<string>) {
   const coreClientType: string = name === "Error" ? "ErrorModel" : name;
   coreClientTypes.add(coreClientType);
   return coreClientType;
 }
 
+function getCoreLroType(name: string, coreLroTypes: Set<string>) {
+  const coreLroType = name === "OperationState" ? "CoreOperationStatus" : name;
+  coreLroTypes.add(coreLroType);
+  return coreLroType;
+}
+
 // ====== TYPE EXTRACTION ======
 
 function extractModels(codeModel: ModularCodeModel): Type[] {
   const models = codeModel.types.filter(
     (t) =>
-      (t.type === "model" || t.type === "enum") &&
-      !isAzureCoreErrorSdkType(t) &&
-      !(t.type == "model" && t.name === "")
+      ((t.type === "model" || t.type === "enum") &&
+        !isAzureCoreErrorSdkType(t) &&
+        !isAzureCoreLroSdkType(t) &&
+        !isAnonymousModel(t)) ||
+      isModelWithAdditionalProperties(t)
   );
 
   for (const model of codeModel.types) {
@@ -59,7 +83,10 @@ function extractModels(codeModel: ModularCodeModel): Type[] {
 export function extractAliases(codeModel: ModularCodeModel): Type[] {
   const models = codeModel.types.filter(
     (t) =>
-      (t.type === "model" || t.type === "combined") && t.alias && t.aliasType
+      ((t.type === "model" || t.type === "combined") &&
+        t.alias &&
+        t.aliasType) ||
+      (isModelWithAdditionalProperties(t) && t.alias && t.aliasType)
   );
   return models;
 }
@@ -102,7 +129,7 @@ type InterfaceStructure = OptionalKind<InterfaceDeclarationStructure> & {
 
 export function buildModelInterface(
   model: Type,
-  cache: { coreClientTypes: Set<string> }
+  cache: { coreClientTypes: Set<string>; coreLroTypes: Set<string> }
 ): InterfaceStructure {
   const modelProperties = model.properties ?? [];
   const modelInterface = {
@@ -114,9 +141,13 @@ export function buildModelInterface(
       const propertyMetadata = getType(p.type, p.format);
       let propertyTypeName = propertyMetadata.name;
       if (isAzureCoreErrorSdkType(p.type)) {
-        propertyTypeName = isAzureCoreErrorSdkType(p.type)
-          ? getCoreClientErrorType(propertyTypeName, cache.coreClientTypes)
-          : propertyTypeName;
+        propertyTypeName = getCoreClientErrorType(
+          propertyTypeName,
+          cache.coreClientTypes
+        );
+      }
+      if (isAzureCoreLroSdkType(p.type)) {
+        propertyTypeName = getCoreLroType(propertyTypeName, cache.coreLroTypes);
       }
 
       return {
@@ -142,6 +173,7 @@ export function buildModels(
 ): SourceFile | undefined {
   // We are generating both models and enums here
   const coreClientTypes = new Set<string>();
+  const coreLroTypes = new Set<string>();
   // filter out the models/enums that are anonymous
   const models = extractModels(codeModel).filter((m) => !!m.name);
   const aliases = extractAliases(codeModel);
@@ -163,12 +195,21 @@ export function buildModels(
       const enumAlias = buildEnumModel(model);
       modelsFile.addTypeAlias(enumAlias);
     } else {
-      const modelInterface = buildModelInterface(model, { coreClientTypes });
-      model.type === "model"
-        ? model.parents?.forEach((p) =>
-            modelInterface.extends.push(p.alias ?? getType(p, p.format).name)
-          )
-        : undefined;
+      const modelInterface = buildModelInterface(model, {
+        coreClientTypes,
+        coreLroTypes
+      });
+
+      model.parents?.forEach((p) =>
+        modelInterface.extends.push(p.alias ?? getType(p, p.format).name)
+      );
+      if (isModelWithAdditionalProperties(model)) {
+        addExtendedDictInfo(
+          model,
+          modelInterface,
+          codeModel.modularOptions.compatibilityMode
+        );
+      }
       modelsFile.addInterface(modelInterface);
     }
   }
@@ -185,12 +226,58 @@ export function buildModels(
     ]);
   }
 
+  if (coreLroTypes.size > 0) {
+    modelsFile.addImportDeclarations([
+      {
+        moduleSpecifier: getImportSpecifier(
+          "azureCoreLro",
+          codeModel.runtimeImports
+        ),
+        namedImports: Array.from(coreLroTypes).map((t) =>
+          t === "CoreOperationStatus"
+            ? "OperationStatus as CoreOperationStatus"
+            : t
+        )
+      }
+    ]);
+  }
+
   aliases.forEach((alias) => {
     modelsFile.addTypeAlias(buildModelTypeAlias(alias));
   });
   return modelsFile;
 }
 
+function addExtendedDictInfo(
+  model: Type,
+  modelInterface: InterfaceStructure,
+  compatibilityMode: boolean = false
+) {
+  if (
+    (model.properties &&
+      model.properties.length > 0 &&
+      model.elementType &&
+      model.properties?.every((p) => {
+        return getType(model.elementType!)?.name.includes(getType(p.type).name);
+      })) ||
+    (model.properties?.length === 0 && model.elementType)
+  ) {
+    modelInterface.extends.push(
+      `Record<string, ${getType(model.elementType!).name ?? "any"}>`
+    );
+  } else if (compatibilityMode) {
+    modelInterface.extends.push(`Record<string, any>`);
+  } else {
+    modelInterface.properties?.push({
+      name: "additionalProperties",
+      docs: ["Additional properties"],
+      hasQuestionToken: true,
+      isReadonly: false,
+      type: `Record<string, ${getType(model.elementType!).name ?? "any"}>`
+    });
+  }
+}
+
 export function buildModelTypeAlias(model: Type) {
   return {
     name: model.name!,

package/src/modular/helpers/operationHelpers.ts

@@ -59,6 +59,15 @@ function getRLCResponseType(rlcResponse?: OperationResponse) {
     .join(" | ");
 }
 
+function getRLCLroLogicalResponse(rlcResponse?: OperationResponse) {
+  const logicalResponse = (rlcResponse?.responses ?? []).filter(
+    (r) => r.predefinedName && r.predefinedName.endsWith(`LogicalResponse`)
+  );
+  return logicalResponse.length > 0
+    ? logicalResponse[0]!.predefinedName!
+    : "any";
+}
+
 export function getSendPrivateFunction(
   dpgContext: SdkContext,
   operation: Operation,
@@ -109,18 +118,22 @@ export function getDeserializePrivateFunction(
   runtimeImports: RuntimeImports
 ): OptionalKind<FunctionDeclarationStructure> {
   const { name } = getOperationName(operation);
-
   const parameters: OptionalKind<ParameterDeclarationStructure>[] = [
     {
       name: "result",
       type: getRLCResponseType(operation.rlcResponse)
     }
   ];
+  // TODO: Support LRO + paging operation
+  // https://github.com/Azure/autorest.typescript/issues/2313
+  const isLroOnly = isLroOnlyOperation(operation);
 
   // TODO: Support operation overloads
   const response = operation.responses[0]!;
   let returnType;
-  if (response?.type?.type) {
+  if (isLroOnly && operation.method.toLowerCase() !== "patch") {
+    returnType = buildLroReturnType(operation);
+  } else if (response?.type?.type) {
     returnType = buildType(
       response.type.name,
       response.type,
@@ -166,33 +179,69 @@ export function getDeserializePrivateFunction(
     }
   }
 
-  const allParents = getAllAncestors(response.type);
-  const properties = getAllProperties(response.type, allParents) ?? [];
+  let deserializedType = isLroOnly
+    ? operation?.lroMetadata?.finalResult
+    : response.type;
+  let hasLroSubPath = operation?.lroMetadata?.finalResultPath !== undefined;
+  let deserializedRoot = hasLroSubPath
+    ? `result.body.${operation?.lroMetadata?.finalResultPath}`
+    : "result.body";
+  // TODO: Hard-coded for LRO PATCH case for now
+  // https://github.com/Azure/autorest.typescript/issues/2314
+  if (isLroOnly && operation.method.toLowerCase() === "patch") {
+    deserializedType = response.type;
+    hasLroSubPath = false;
+    deserializedRoot = "result.body";
+  }
+  if (isLroOnly) {
+    const lroLogicalResponse = getRLCLroLogicalResponse(operation.rlcResponse);
+    statements.push(`result = result as ${lroLogicalResponse};`);
+    if (hasLroSubPath) {
+      statements.push(
+        `if(${deserializedRoot.split(".").join("?.")} === undefined) {
+          throw createRestError(\`Expected a result in the response at position "${deserializedRoot}"\`, result);
+        }
+        `
+      );
+    }
+  }
+
+  const allParents = deserializedType ? getAllAncestors(deserializedType) : [];
+  const properties = deserializedType
+    ? getAllProperties(deserializedType, allParents)
+    : [];
   if (
-    response?.type?.type === "any" ||
+    deserializedType?.type === "any" ||
+    deserializedType?.type === "dict" ||
+    (deserializedType?.type === "model" &&
+      allParents.some((p) => p.type === "dict")) ||
     response.isBinaryPayload ||
-    response?.type?.aliasType
+    deserializedType?.aliasType
   ) {
     statements.push(`return result.body`);
-  } else if (properties.length > 0) {
+  } else if (deserializedType && properties.length > 0) {
     statements.push(
       `return {`,
-      getResponseMapping(response.type, "result.body", runtimeImports).join(
-        ","
-      ),
+      getResponseMapping(
+        deserializedType,
+        deserializedRoot,
+        runtimeImports
+      ).join(","),
       `}`
     );
-  } else if (returnType.type === "void") {
+  } else if (returnType.type === "void" || deserializedType === undefined) {
     statements.push(`return;`);
   } else {
     statements.push(
       `return ${deserializeResponseValue(
-        response.type,
-        "result.body",
+        deserializedType,
+        deserializedRoot,
         runtimeImports,
-        response.type.nullable !== undefined ? !response.type.nullable : false,
-        [response.type],
-        response.type.format
+        deserializedType.nullable !== undefined
+          ? !deserializedType.nullable
+          : false,
+        [deserializedType],
+        deserializedType.format
       )}`
     );
   }
@@ -257,19 +306,115 @@ export function getOperationFunction(
   operation: Operation,
   clientType: string
 ): OptionalKind<FunctionDeclarationStructure> & { propertyName?: string } {
+  if (isPagingOnlyOperation(operation)) {
+    // Case 1: paging-only operation
+    return getPagingOnlyOperationFunction(operation, clientType);
+  } else if (isLroOnlyOperation(operation)) {
+    // Case 2: lro-only operation
+    return getLroOnlyOperationFunction(operation, clientType);
+  } else if (isLroAndPagingOperation(operation)) {
+    // Case 3: both paging + lro operation is not supported yet so handle them as normal operation and customization may be needed
+    // https://github.com/Azure/autorest.typescript/issues/2313
+  }
+
+  // Extract required parameters
+  const parameters: OptionalKind<ParameterDeclarationStructure>[] =
+    getOperationSignatureParameters(operation, clientType);
+  // TODO: Support operation overloads
+  const response = operation.responses[0]!;
+  let returnType = { name: "", type: "void" };
+  if (response.type?.type) {
+    const type =
+      extractPagingType(response.type, operation.itemName) ?? response.type;
+    returnType = buildType(type.name, type, type.format);
+  }
+  const { name, fixme = [] } = getOperationName(operation);
+  const functionStatement = {
+    docs: [
+      ...getDocsFromDescription(operation.description),
+      ...getFixmeForMultilineDocs(fixme)
+    ],
+    isAsync: true,
+    isExported: true,
+    name,
+    propertyName: operation.name,
+    parameters,
+    returnType: `Promise<${returnType.type}>`
+  };
+
+  const statements: string[] = [];
+  statements.push(
+    `const result = await _${name}Send(${parameters
+      .map((p) => p.name)
+      .join(", ")});`
+  );
+  statements.push(`return _${name}Deserialize(result);`);
+
+  return {
+    ...functionStatement,
+    statements
+  };
+}
+
+function getLroOnlyOperationFunction(operation: Operation, clientType: string) {
+  // Extract required parameters
+  const parameters: OptionalKind<ParameterDeclarationStructure>[] =
+    getOperationSignatureParameters(operation, clientType);
+  const returnType = buildLroReturnType(operation);
+  const { name, fixme = [] } = getOperationName(operation);
+  const functionStatement = {
+    docs: [
+      ...getDocsFromDescription(operation.description),
+      ...getFixmeForMultilineDocs(fixme)
+    ],
+    isAsync: false,
+    isExported: true,
+    name,
+    propertyName: operation.name,
+    parameters,
+    returnType: `PollerLike<OperationState<${returnType.type}>, ${returnType.type}>`
+  };
+
+  const statements: string[] = [];
+  statements.push(`
+  return getLongRunningPoller(context, _${name}Deserialize, {
+    updateIntervalInMs: options?.updateIntervalInMs,
+    abortSignal: options?.abortSignal,
+    getInitialResponse: () => _${name}Send(${parameters
+      .map((p) => p.name)
+      .join(", ")})
+  }) as PollerLike<OperationState<${returnType.type}>, ${returnType.type}>;
+  `);
+
+  return {
+    ...functionStatement,
+    statements
+  };
+}
+
+function buildLroReturnType(operation: Operation) {
+  const metadata = operation.lroMetadata;
+  if (metadata !== undefined && metadata.finalResult !== undefined) {
+    const type = metadata.finalResult;
+    return buildType(type.name, type, type.format);
+  }
+  return { name: "", type: "void" };
+}
+
+function getPagingOnlyOperationFunction(
+  operation: Operation,
+  clientType: string
+) {
   // Extract required parameters
   const parameters: OptionalKind<ParameterDeclarationStructure>[] =
     getOperationSignatureParameters(operation, clientType);
-  const isPaging = isPagingOperation(operation);
 
   // TODO: Support operation overloads
   const response = operation.responses[0]!;
   let returnType = { name: "", type: "void" };
   if (response.type?.type) {
-    let type = response.type;
-    if (isPaging) {
-      type = extractPagingType(type, operation.itemName) ?? type;
-    }
+    const type =
+      extractPagingType(response.type, operation.itemName) ?? response.type;
     returnType = buildType(type.name, type, type.format);
   }
   const { name, fixme = [] } = getOperationName(operation);
@@ -278,41 +423,30 @@ export function getOperationFunction(
       ...getDocsFromDescription(operation.description),
       ...getFixmeForMultilineDocs(fixme)
     ],
-    isAsync: !isPaging,
+    isAsync: false,
     isExported: true,
     name,
     propertyName: operation.name,
     parameters,
-    returnType: isPaging
-      ? `PagedAsyncIterableIterator<${returnType.type}>`
-      : `Promise<${returnType.type}>`
+    returnType: `PagedAsyncIterableIterator<${returnType.type}>`
   };
 
   const statements: string[] = [];
-  if (isPaging) {
-    const options = [];
-    if (operation.itemName) {
-      options.push(`itemName: "${operation.itemName}"`);
-    }
-    if (operation.continuationTokenName) {
-      options.push(`nextLinkName: "${operation.continuationTokenName}"`);
-    }
-    statements.push(
-      `return buildPagedAsyncIterator(
-        context, 
-        () => _${name}Send(${parameters.map((p) => p.name).join(", ")}), 
-        _${name}Deserialize,
-        ${options.length > 0 ? `{${options.join(", ")}}` : ``}
-        );`
-    );
-  } else {
-    statements.push(
-      `const result = await _${name}Send(${parameters
-        .map((p) => p.name)
-        .join(", ")});`
-    );
-    statements.push(`return _${name}Deserialize(result);`);
+  const options = [];
+  if (operation.itemName) {
+    options.push(`itemName: "${operation.itemName}"`);
+  }
+  if (operation.continuationTokenName) {
+    options.push(`nextLinkName: "${operation.continuationTokenName}"`);
   }
+  statements.push(
+    `return buildPagedAsyncIterator(
+      context, 
+      () => _${name}Send(${parameters.map((p) => p.name).join(", ")}), 
+      _${name}Deserialize,
+      ${options.length > 0 ? `{${options.join(", ")}}` : ``}
+      );`
+  );
 
   return {
     ...functionStatement,
@@ -453,7 +587,12 @@ function buildBodyParameter(
     return "";
   }
 
-  if (bodyParameter.type.type === "model" && !bodyParameter.type.aliasType) {
+  const allParents = getAllAncestors(bodyParameter.type);
+  if (
+    bodyParameter.type.type === "model" &&
+    !bodyParameter.type.aliasType &&
+    !allParents.some((p) => p.type === "dict")
+  ) {
     const bodyParts: string[] = getRequestModelMapping(
       bodyParameter.type,
       bodyParameter.clientName,
@@ -470,8 +609,10 @@ function buildBodyParameter(
       return `\nbody: ${bodyParameter.clientName},`;
     }
   } else if (
-    bodyParameter.type.type === "model" &&
-    bodyParameter.type.aliasType
+    (bodyParameter.type.type === "model" &&
+      (bodyParameter.type.aliasType ||
+        allParents.some((p) => p.type === "dict"))) ||
+    bodyParameter.type.type === "dict"
   ) {
     return `\nbody: ${bodyParameter.clientName},`;
   }
@@ -790,7 +931,7 @@ export function getRequestModelMapping(
     const propertyFullName = `${propertyPath}.${property.clientName}`;
     if (property.type.type === "model") {
       let definition;
-      if (property.type.isCoreErrorType) {
+      if (property.type.coreTypeInfo === "ErrorType") {
         definition = `"${property.restApiName}": ${getNullableCheck(
           propertyFullName,
           property.type
@@ -885,7 +1026,7 @@ export function getResponseMapping(
     const propertyFullName = `${propertyPath}.${property.restApiName}`;
     if (property.type.type === "model") {
       let definition;
-      if (property.type.isCoreErrorType) {
+      if (property.type.coreTypeInfo === "ErrorType") {
         definition = `"${property.clientName}": ${getNullableCheck(
           propertyFullName,
           property.type
@@ -1173,29 +1314,23 @@ function needsDeserialize(type?: Type) {
   );
 }
 
-export function hasLROOperation(
-  codeModel: ModularCodeModel,
-  needRLC: boolean = false
-) {
-  return (codeModel.clients ?? []).some(
-    (c) =>
-      (needRLC ? c.rlcHelperDetails.hasLongRunning : false) ||
-      (c.operationGroups ?? []).some((og) =>
-        (og.operations ?? []).some(isLROOperation)
-      )
-  );
+export function isLroAndPagingOperation(op: Operation): boolean {
+  return op.discriminator === "lropaging";
 }
 
-export function isLROOperation(op: Operation): boolean {
-  return op.discriminator === "lro" || op.discriminator === "lropaging";
+export function isLroOnlyOperation(op: Operation): boolean {
+  return op.discriminator === "lro";
 }
 
-export function hasPagingOperation(client: Client, needRLC?: boolean): boolean;
-export function hasPagingOperation(
+export function hasPagingOnlyOperation(
+  client: Client,
+  needRLC?: boolean
+): boolean;
+export function hasPagingOnlyOperation(
   codeModel: ModularCodeModel,
   needRLC?: boolean
 ): boolean;
-export function hasPagingOperation(
+export function hasPagingOnlyOperation(
   clientOrCodeModel: Client | ModularCodeModel,
   needRLC: boolean = false
 ): boolean {
@@ -1209,13 +1344,13 @@ export function hasPagingOperation(
     (c) =>
       (needRLC ? c.rlcHelperDetails.hasPaging : false) ||
       (c.operationGroups ?? []).some((og) =>
-        (og.operations ?? []).some(isPagingOperation)
+        (og.operations ?? []).some(isPagingOnlyOperation)
       )
   );
 }
 
-export function isPagingOperation(op: Operation): boolean {
-  return op.discriminator === "paging" || op.discriminator === "lropaging";
+export function isPagingOnlyOperation(op: Operation): boolean {
+  return op.discriminator === "paging";
 }
 
 export function getAllProperties(type: Type, parents?: Type[]): Property[] {

package/src/modular/helpers/typeHelpers.ts

@@ -30,7 +30,7 @@ const simpleTypeMap: Record<string, TypeMetadata> = {
   "byte-array": { name: "Uint8Array" },
   string: { name: "string" },
   any: { name: "Record<string, any>" },
-  unknown: { name: "unknown" }
+  unknown: { name: "any" }
 };
 
 function handleAnomymousModelName(type: Type) {
@@ -232,7 +232,11 @@ function handleDictType(type: Type): TypeMetadata {
   if (!type.elementType) {
     throw new Error("Unable to process dict without elemetType info");
   }
-
+  if (type.name && type.name !== "Record") {
+    return {
+      name: type.name
+    };
+  }
   const elementType = getType(type.elementType, type.elementType.format);
   const elementName = elementType.name;
   return {

package/src/modular/interfaces.ts

@@ -8,3 +8,9 @@ export interface ClientDetails {
   baseUrl?: string;
   credentialsParam?: Parameter;
 }
+
+export interface OperationPathAndDeserDetails {
+  path: string;
+  deserName: string;
+  renamedDeserName?: string;
+}

package/src/modular/modularCodeModel.ts

@@ -6,6 +6,7 @@ import { Project } from "ts-morph";
 
 export interface ModularOptions {
   sourceRoot: string;
+  compatibilityMode: boolean;
 }
 export interface ModularCodeModel {
   options: RLCOptions;
@@ -101,7 +102,7 @@ export interface Type {
   format?: string;
   properties?: Property[];
   types?: Type[];
-  isCoreErrorType?: boolean;
+  coreTypeInfo?: "ErrorType" | "LroType";
   usage?: UsageFlags;
   alias?: string;
   aliasType?: string;
@@ -182,4 +183,12 @@ export interface Operation {
   addedOn?: string;
   rlcResponse?: OperationResponse;
   namespaceHierarchies: string[];
+  lroMetadata?: LroOperationMetadata;
+}
+
+export interface LroOperationMetadata {
+  finalStateVia?: string;
+  finalResult?: Type;
+  /** The path to the field in the 'finalEnvelopeResult' that contains the 'finalResult'. */
+  finalResultPath?: string;
 }

package/src/transform/transformHelperFunctionDetails.ts

@@ -23,7 +23,7 @@ export function transformHelperFunctionDetails(
 ): HelperFunctionDetails {
   const program = dpgContext.program;
   const serializeInfo = extractSpecialSerializeInfo(client, dpgContext);
-  // Disbale paging and long running for non-Azure clients.
+  // Disable paging and long running for non-Azure clients.
   if (flavor !== "azure") {
     return {
       hasLongRunning: false,

package/src/transform/transformParameters.ts

@@ -11,7 +11,7 @@ import {
   SchemaContext,
   ApiVersionInfo
 } from "@azure-tools/rlc-common";
-import { ignoreDiagnostics, Type } from "@typespec/compiler";
+import { ignoreDiagnostics, isVoidType, Type } from "@typespec/compiler";
 import {
   getHttpOperation,
   HttpOperation,
@@ -259,7 +259,7 @@ function transformBodyParameters(
     (parameters.bodyType ?? parameters.bodyParameter?.type) && inputBodyType
       ? inputBodyType
       : parameters.bodyType ?? parameters.bodyParameter?.type;
-  if (!bodyType) {
+  if (!bodyType || isVoidType(bodyType)) {
     return;
   }
   return transformRequestBody(

package/src/transform/transformPaths.ts

@@ -115,7 +115,7 @@ function transformOperation(
         responseTypes,
         operationGroupName
       ),
-      isPageable: isPagingOperation(program, route)
+      isPaging: isPagingOperation(program, route)
     }
   };
   if (