@azure-tools/typespec-ts 0.12.0 → 0.13.0

package/package.json

@@ -1,28 +1,9 @@
 {
   "name": "@azure-tools/typespec-ts",
-  "version": "0.12.0",
+  "version": "0.13.0",
   "description": "An experimental CADL emitter for TypeScript RLC",
   "main": "dist/src/index.js",
   "type": "module",
-  "scripts": {
-    "clean": "rimraf ./dist ./cadl-output",
-    "build": "tsc -p .",
-    "test": "npm run unit-test && npm run integration-test-ci",
-    "lint": "eslint src --ext .ts --max-warnings=0",
-    "lint:fix": "eslint src --fix --ext .ts",
-    "format": "npm run -s prettier -- --write",
-    "check-format": "npm run prettier -- --check",
-    "prettier": "prettier --config ./.prettierrc src/**/*.ts",
-    "check:tree": "ts-node ./test/commands/check-clean-tree.ts",
-    "integration-test-ci": "npm run start-test-server & npm run copy:typespec && npm run generate-and-run",
-    "start-test-server": "mkdirp -p coverage && npx cadl-ranch serve ./node_modules/@azure-tools/cadl-ranch-specs/http  --coverageFile ./coverage/cadl-ranch-coverage-typescript.json",
-    "copy:typespec": "rm -rf temp && mkdirp -p temp && cp -r ./node_modules/@azure-tools/cadl-ranch-specs/http ./temp",
-    "generate-and-run": "npm run generate-cadl-only && npm run integration-test:alone && npm run stop-test-server",
-    "generate-cadl-only": "ts-node ./test/commands/gen-cadl-ranch.ts",
-    "integration-test:alone": "cross-env TS_NODE_PROJECT=tsconfig.test.json mocha -r ts-node/register --experimental-specifier-resolution=node --timeout 2000 ./test/integration/*.spec.ts",
-    "stop-test-server": "npx cadl-ranch server stop",
-    "unit-test": "cross-env TS_NODE_PROJECT=tsconfig.json mocha -r ts-node/register --experimental-specifier-resolution=node --experimental-modules=true './test/unit/**/*.spec.ts'"
-  },
   "author": "Jose Heredia <joheredi@microsoft.com>",
   "license": "MIT",
   "devDependencies": {
@@ -33,7 +14,7 @@
     "@types/fs-extra": "^9.0.13",
     "@typescript-eslint/eslint-plugin": "^5.58.0",
     "@typescript-eslint/parser": "^5.58.0",
-    "@typespec/http": "~0.43.0",
+    "@typespec/http": "~0.44.0",
     "chai": "^4.3.6",
     "mkdirp": "^2.1.2",
     "eslint": "^8.9.0",
@@ -42,30 +23,33 @@
     "ts-node": "^10.9.1",
     "typescript": "~5.0.0",
     "prettier": "~2.7.1",
-    "@azure-tools/cadl-ranch-specs": "~0.11.2",
-    "@typespec/versioning": "~0.43.0",
-    "@azure-tools/cadl-ranch-expect": "^0.2.2",
-    "@azure-tools/cadl-ranch": "~0.4.4",
+    "@azure-tools/cadl-ranch-specs": "~0.14.10",
+    "@typespec/versioning": "~0.44.0",
+    "@azure-tools/cadl-ranch-expect": "^0.3.0",
+    "@azure-tools/cadl-ranch": "~0.4.13",
     "chalk": "^4.0.0",
-    "@azure-rest/core-client": "^1.1.2",
+    "@azure-rest/core-client": "^1.1.3",
     "@azure/core-auth": "^1.3.2",
     "cross-env": "^7.0.3",
     "@azure/core-paging": "^1.5.0",
-    "@azure/core-lro": "^2.2.0",
-    "@azure/core-rest-pipeline": "^1.9.2"
+    "@azure/core-lro": "^2.5.3",
+    "@azure/core-rest-pipeline": "^1.9.2",
+    "@azure/logger": "^1.0.4"
+  },
+  "peerDependencies": {
+    "@azure-tools/typespec-azure-core": ">=0.30.0 <1.0.0",
+    "@azure-tools/typespec-client-generator-core": ">=0.30.0 <1.0.0",
+    "@typespec/compiler": ">=0.44.0 <1.0.0",
+    "@typespec/http": ">=0.44.0 <1.0.0",
+    "@typespec/rest": ">=0.44.0 <1.0.0",
+    "@typespec/versioning": ">=0.44.0 <1.0.0"
   },
   "dependencies": {
-    "@typespec/compiler": "~0.43.0",
-    "@azure-tools/typespec-azure-core": "~0.29.0",
-    "@typespec/rest": "~0.43.0",
     "prettier": "^2.6.1",
     "tslib": "^2.3.1",
-    "@azure-tools/rlc-common": "^0.12.0",
+    "@azure-tools/rlc-common": "^0.13.0",
     "ts-morph": "^15.1.0",
-    "@azure-tools/typespec-client-generator-core": "~0.29.0",
-    "fs-extra": "^11.1.0",
-    "@typespec/openapi": "0.43.0",
-    "@typespec/openapi3": "0.43.0"
+    "fs-extra": "^11.1.0"
   },
   "mocha": {
     "extension": [
@@ -76,5 +60,24 @@
   "bugs": {
     "url": "https://github.com/Azure/autorest.typescript/issues"
   },
-  "homepage": "https://github.com/Azure/autorest.typescript/tree/main/packages/typespec-ts/"
-}
+  "homepage": "https://github.com/Azure/autorest.typescript/tree/main/packages/typespec-ts/",
+  "scripts": {
+    "clean": "rimraf ./dist ./cadl-output",
+    "build": "tsc -p .",
+    "test": "npm run unit-test && npm run integration-test-ci",
+    "lint": "eslint src --ext .ts --max-warnings=0",
+    "lint:fix": "eslint src --fix --ext .ts",
+    "format": "npm run -s prettier -- --write",
+    "check-format": "npm run prettier -- --check",
+    "prettier": "prettier --config ./.prettierrc src/**/*.ts",
+    "check:tree": "ts-node ./test/commands/check-clean-tree.ts",
+    "integration-test-ci": "npm run start-test-server & npm run copy:typespec && npm run generate-and-run",
+    "start-test-server": "mkdirp -p coverage && npx cadl-ranch serve ./node_modules/@azure-tools/cadl-ranch-specs/http  --coverageFile ./coverage/cadl-ranch-coverage-typescript.json",
+    "copy:typespec": "rm -rf temp && mkdirp -p temp && cp -r ./node_modules/@azure-tools/cadl-ranch-specs/http ./temp",
+    "generate-and-run": "npm run generate-cadl-only && npm run integration-test:alone && npm run stop-test-server",
+    "generate-cadl-only": "ts-node ./test/commands/gen-cadl-ranch.ts",
+    "integration-test:alone": "cross-env TS_NODE_PROJECT=tsconfig.test.json mocha -r ts-node/register --experimental-specifier-resolution=node --timeout 4000 ./test/integration/*.spec.ts",
+    "stop-test-server": "npx cadl-ranch server stop",
+    "unit-test": "cross-env TS_NODE_PROJECT=tsconfig.json mocha -r ts-node/register --experimental-specifier-resolution=node --experimental-modules=true './test/unit/**/*.spec.ts'"
+  }
+}

package/src/index.ts

@@ -25,6 +25,7 @@ import {
   buildSampleTest,
   buildReadmeFile,
   buildSerializeHelper,
+  buildLogger,
   RLCOptions
 } from "@azure-tools/rlc-common";
 import { transformRLCModel } from "./transform/transform.js";
@@ -71,6 +72,7 @@ export async function $onEmit(context: EmitContext) {
     await emitContentByBuilder(program, buildParameterTypes, rlcModels);
     await emitContentByBuilder(program, buildIsUnexpectedHelper, rlcModels);
     await emitContentByBuilder(program, buildIndexFile, rlcModels);
+    await emitContentByBuilder(program, buildLogger, rlcModels);
     await emitContentByBuilder(program, buildTopLevelIndex, rlcModels);
     await emitContentByBuilder(program, buildPaginateHelper, rlcModels);
     await emitContentByBuilder(program, buildPollingHelper, rlcModels);

package/src/modelUtils.ts

@@ -39,7 +39,9 @@ import {
   NumericLiteral,
   Service,
   listServices,
-  Program
+  Program,
+  getEncode,
+  EncodeData
 } from "@typespec/compiler";
 import { reportDiagnostic } from "./lib.js";
 import {
@@ -74,12 +76,15 @@ export function getBinaryType(usage: SchemaContext[]) {
 
 export function getSchemaForType(
   program: Program,
+  dpgContext: SdkContext,
   typeInput: Type,
   usage?: SchemaContext[],
-  needRef?: boolean
+  needRef: boolean = false,
+  relevantProperty?: ModelProperty
 ) {
   const type = getEffectiveModelFromType(program, typeInput);
-  const builtinType = mapCadlTypeToTypeScript(program, type, usage);
+
+  const builtinType = mapCadlTypeToTypeScript(program, dpgContext, type, usage);
   if (builtinType !== undefined) {
     // add in description elements for types derived from primitive types (SecureString, etc.)
     const doc = getDoc(program, type);
@@ -89,7 +94,13 @@ export function getSchemaForType(
     return builtinType;
   }
   if (type.kind === "Model") {
-    const schema = getSchemaForModel(program, type, usage, needRef) as any;
+    const schema = getSchemaForModel(
+      program,
+      dpgContext,
+      type,
+      usage,
+      needRef
+    ) as any;
     if (usage && usage.includes(SchemaContext.Output)) {
       schema.outputTypeName = `${schema.name}Output`;
       schema.typeName = `${schema.name}`;
@@ -97,13 +108,13 @@ export function getSchemaForType(
     schema.usage = usage;
     return schema;
   } else if (type.kind === "Union") {
-    return getSchemaForUnion(program, type, usage);
+    return getSchemaForUnion(program, dpgContext, type, usage);
   } else if (type.kind === "UnionVariant") {
-    return getSchemaForUnionVariant(program, type, usage);
+    return getSchemaForUnionVariant(program, dpgContext, type, usage);
   } else if (type.kind === "Enum") {
     return getSchemaForEnum(program, type);
   } else if (type.kind === "Scalar") {
-    return getSchemaForScalar(program, type);
+    return getSchemaForScalar(program, dpgContext, type, relevantProperty);
   }
   if (isUnknownType(type)) {
     const returnType: any = { type: "unknown" };
@@ -152,16 +163,22 @@ export function includeDerivedModel(model: Model): boolean {
   );
 }
 
-function getSchemaForScalar(program: Program, scalar: Scalar) {
-  let result = getSchemaForStdScalar(program, scalar);
+function getSchemaForScalar(
+  program: Program,
+  dpgContext: SdkContext,
+  scalar: Scalar,
+  relevantProperty?: ModelProperty
+) {
+  let result = getSchemaForStdScalar(program, scalar, relevantProperty);
   if (!result && scalar.baseScalar) {
-    result = getSchemaForScalar(program, scalar.baseScalar);
+    result = getSchemaForScalar(program, dpgContext, scalar.baseScalar);
   }
   return applyIntrinsicDecorators(program, scalar, result);
 }
 
 function getSchemaForUnion(
   program: Program,
+  dpgContext: SdkContext,
   union: Union,
   usage?: SchemaContext[]
 ) {
@@ -170,7 +187,7 @@ function getSchemaForUnion(
 
   for (const variant of variants) {
     // We already know it's not a model type
-    values.push(getSchemaForType(program, variant.type, usage));
+    values.push(getSchemaForType(program, dpgContext, variant.type, usage));
   }
 
   const schema: any = {};
@@ -202,10 +219,11 @@ function getSchemaForUnion(
 
 function getSchemaForUnionVariant(
   program: Program,
+  dpgContext: SdkContext,
   variant: UnionVariant,
   usage?: SchemaContext[]
 ): Schema {
-  return getSchemaForType(program, variant, usage);
+  return getSchemaForType(program, dpgContext, variant, usage);
 }
 
 // An openapi "string" can be defined in several different ways in Cadl
@@ -323,26 +341,10 @@ function isSchemaProperty(program: Program, property: ModelProperty) {
   const statusCodeinfo = isStatusCode(program, property);
   return !(headerInfo || queryInfo || pathInfo || statusCodeinfo);
 }
-// function getDefaultValue(program: Program, type: Type): any {
-//   switch (type.kind) {
-//     case "String":
-//       return type.value;
-//     case "Number":
-//       return type.value;
-//     case "Boolean":
-//       return type.value;
-//     case "Tuple":
-//       return type.values.map(item => getDefaultValue(program, item));
-//     default:
-//       reportDiagnostic(program, {
-//         code: "invalid-default",
-//         format: { type: type.kind },
-//         target: type,
-//       });
-//   }
-// }
+
 function getSchemaForModel(
   program: Program,
+  dpgContext: SdkContext,
   model: Model,
   usage?: SchemaContext[],
   needRef?: boolean
@@ -413,8 +415,13 @@ function getSchemaForModel(
             }
           })
           .join("");
-        modelSchema.alias = `Paged<${templateName}>`;
-        modelSchema.outputAlias = `Paged<${templateName}Output>`;
+        if (
+          paged.itemsProperty.name === "value" &&
+          paged.nextLinkProperty?.name === "nextLink"
+        ) {
+          modelSchema.alias = `Paged<${templateName}>`;
+          modelSchema.outputAlias = `Paged<${templateName}Output>`;
+        }
       }
     }
   }
@@ -430,10 +437,23 @@ function getSchemaForModel(
     };
   }
   for (const child of derivedModels) {
-    const childSchema = getSchemaForType(program, child, usage, true);
+    const childSchema = getSchemaForType(
+      program,
+      dpgContext,
+      child,
+      usage,
+      true
+    );
     for (const [name, prop] of child.properties) {
       if (name === discriminator?.propertyName) {
-        const propSchema = getSchemaForType(program, prop.type, usage, true);
+        const propSchema = getSchemaForType(
+          program,
+          dpgContext,
+          prop.type,
+          usage,
+          true,
+          prop
+        );
         childSchema.discriminatorValue = propSchema.type.replace(/"/g, "");
         break;
       }
@@ -476,7 +496,14 @@ function getSchemaForModel(
       continue;
     }
 
-    const propSchema = getSchemaForType(program, prop.type, usage, true);
+    const propSchema = getSchemaForType(
+      program,
+      dpgContext,
+      prop.type,
+      usage,
+      true,
+      prop
+    );
     if (propSchema === undefined) {
       continue;
     }
@@ -501,17 +528,18 @@ function getSchemaForModel(
     }
 
     // Apply decorators on the property to the type's schema
-    const newPropSchema = applyIntrinsicDecorators(program, prop, propSchema);
+    const newPropSchema = applyIntrinsicDecorators(
+      program,
+
+      prop,
+      propSchema
+    );
     if (newPropSchema === undefined) {
       continue;
     }
     // Use the description from ModelProperty not devired from Model Type
     newPropSchema.description = propertyDescription;
 
-    if (prop.default) {
-      // modelSchema.properties[name]['default'] = getDefaultValue(program, prop.default);
-    }
-
     // Should the property be marked as readOnly?
     const vis = getVisibility(program, prop);
     if (vis && vis.includes("read")) {
@@ -549,15 +577,24 @@ function getSchemaForModel(
   ) {
     // Take the base model schema but carry across the documentation property
     // that we set before
-    const baseSchema = getSchemaForType(program, model.baseModel, usage);
+    const baseSchema = getSchemaForType(
+      program,
+      dpgContext,
+      model.baseModel,
+      usage
+    );
     modelSchema = {
       ...baseSchema,
       description: modelSchema.description
     };
   } else if (model.baseModel) {
     modelSchema.parents = {
-      all: [getSchemaForType(program, model.baseModel, usage, true)],
-      immediate: [getSchemaForType(program, model.baseModel, usage, true)]
+      all: [
+        getSchemaForType(program, dpgContext, model.baseModel, usage, true)
+      ],
+      immediate: [
+        getSchemaForType(program, dpgContext, model.baseModel, usage, true)
+      ]
     };
   }
   return modelSchema;
@@ -566,6 +603,7 @@ function getSchemaForModel(
 // OA schema is just a regular object schema.
 function mapCadlTypeToTypeScript(
   program: Program,
+  dpgContext: SdkContext,
   cadlType: Type,
   usage?: SchemaContext[]
 ): any {
@@ -577,7 +615,7 @@ function mapCadlTypeToTypeScript(
     case "Boolean":
       return { type: `${cadlType.value}` };
     case "Model":
-      return mapCadlStdTypeToTypeScript(program, cadlType, usage);
+      return mapCadlStdTypeToTypeScript(program, dpgContext, cadlType, usage);
   }
   if (cadlType.kind === undefined) {
     if (typeof cadlType === "string") {
@@ -685,6 +723,7 @@ function getSchemaForEnum(program: Program, e: Enum) {
  */
 function mapCadlStdTypeToTypeScript(
   program: Program,
+  dpgContext: SdkContext,
   cadlType: Model,
   usage?: SchemaContext[]
 ): any | undefined {
@@ -696,6 +735,7 @@ function mapCadlStdTypeToTypeScript(
       if (name === "string") {
         const valueType = getSchemaForType(
           program,
+          dpgContext,
           indexer.value!,
           usage,
           true
@@ -727,7 +767,13 @@ function mapCadlStdTypeToTypeScript(
       } else if (name === "integer") {
         schema = {
           type: "array",
-          items: getSchemaForType(program, indexer.value!, usage, true),
+          items: getSchemaForType(
+            program,
+            dpgContext,
+            indexer.value!,
+            usage,
+            true
+          ),
           description: getDoc(program, cadlType)
         };
         if (
@@ -779,10 +825,26 @@ function isUnionType(type: Type) {
   return type.kind === "Union";
 }
 
-function getSchemaForStdScalar(program: Program, cadlType: Scalar) {
+function getSchemaForStdScalar(
+  program: Program,
+  cadlType: Scalar,
+  relevantProperty?: ModelProperty
+) {
   if (!program.checker.isStdType(cadlType)) {
     return undefined;
   }
+
+  /**
+   * lookup for @encode decorator
+   *  if absent use typespec type (or default way of serializing that type)
+   *  if present respect type provided in @encode
+   */
+  if (relevantProperty) {
+    const encodeData = getEncode(program, relevantProperty);
+    if (encodeData && isEncodeTypeEffective(cadlType, encodeData)) {
+      cadlType = encodeData.type;
+    }
+  }
   const name = cadlType.name;
   const description = getSummary(program, cadlType);
   switch (name) {
@@ -848,7 +910,9 @@ function getSchemaForStdScalar(program: Program, cadlType: Scalar) {
         format: "float"
       });
     case "string":
-      return applyIntrinsicDecorators(program, cadlType, { type: "string" });
+      return applyIntrinsicDecorators(program, cadlType, {
+        type: "string"
+      });
     case "boolean":
       return { type: "boolean", description };
     case "plainDate":
@@ -867,6 +931,14 @@ function getSchemaForStdScalar(program: Program, cadlType: Scalar) {
         typeName: "Date | string",
         outputTypeName: "string"
       };
+    case "offsetDateTime":
+      return {
+        type: "string",
+        format: "date-time",
+        description,
+        typeName: "Date | string",
+        outputTypeName: "string"
+      };
     case "plainTime":
       return {
         type: "string",
@@ -880,6 +952,28 @@ function getSchemaForStdScalar(program: Program, cadlType: Scalar) {
   }
 }
 
+function isEncodeTypeEffective(
+  type: Scalar,
+  encodeData: EncodeData | undefined
+) {
+  if (!encodeData) {
+    return false;
+  }
+  const datetimeTypes = [
+    "plaindate",
+    "utcdatetime",
+    "offsetdatetime",
+    "plaintime"
+  ];
+  if (
+    datetimeTypes.includes(type.name.toLowerCase()) &&
+    encodeData.type.name === "string"
+  ) {
+    return false;
+  }
+  return true;
+}
+
 export function getTypeName(schema: Schema, usage?: SchemaContext[]): string {
   // TODO: Handle more cases
   return getPriorityName(schema, usage) ?? schema.type ?? "any";
@@ -935,6 +1029,7 @@ export function getFormattedPropertyDoc(
 
 export function getBodyType(
   program: Program,
+
   route: HttpOperation
 ): Type | undefined {
   let bodyModel = route.parameters.bodyType;
@@ -950,6 +1045,7 @@ export function getBodyType(
         if (responseBody) {
           const bodyTypeInResponse = getEffectiveModelFromType(
             program,
+
             responseBody.type
           );
           // response body type is reosurce type, and request body type (if templated) contains resource type

package/src/operationUtil.ts

@@ -1,14 +1,15 @@
 // Copyright (c) Microsoft Corporation.
 // Licensed under the MIT License.
 
-import { NameType, normalizeName } from "@azure-tools/rlc-common";
 import {
-  DecoratedType,
-  ignoreDiagnostics,
-  Model,
-  Program,
-  Type
-} from "@typespec/compiler";
+  NameType,
+  Paths,
+  ResponseMetadata,
+  ResponseTypes,
+  getLroLogicalResponseName,
+  normalizeName
+} from "@azure-tools/rlc-common";
+import { ignoreDiagnostics, Model, Program, Type } from "@typespec/compiler";
 import {
   getHttpOperation,
   HttpOperation,
@@ -16,6 +17,7 @@ import {
   StatusCode
 } from "@typespec/http";
 import {
+  getLroMetadata,
   getPagedResult,
   PagedResultMetadata
 } from "@azure-tools/typespec-azure-core";
@@ -26,6 +28,11 @@ import {
   listOperationsInOperationGroup,
   SdkOperationGroup
 } from "@azure-tools/typespec-client-generator-core";
+import {
+  OperationLroDetail,
+  OPERATION_LRO_LOW_PRIORITY,
+  OPERATION_LRO_HIGH_PRIORITY
+} from "@azure-tools/rlc-common";
 
 export function getNormalizedOperationName(
   route: HttpOperation,
@@ -52,7 +59,11 @@ export function getOperationStatuscode(
 
 // FIXME: this is the placeholder function to extract the operationGroupName
 export function getOperationGroupName(operationGroup?: SdkOperationGroup) {
-  return operationGroup?.type.name ?? "";
+  return normalizeName(
+    operationGroup?.type.name ?? "",
+    NameType.Interface,
+    true
+  );
 }
 
 export function isDefaultStatusCode(statusCode: StatusCode) {
@@ -82,27 +93,105 @@ export function isLongRunningOperation(
   program: Program,
   operation: HttpOperation
 ) {
-  program;
-  for (const resp of operation.responses) {
-    if (!resp.responses || !resp.responses.length) {
-      continue;
-    }
-    if (hasDecorator(operation.operation, "$pollingOperation")) {
-      return true;
-    }
-    for (const unit of resp.responses) {
-      for (const [_, header] of Object.entries(unit.headers!)) {
-        if (hasDecorator(header, "$pollingLocation")) {
-          return true;
+  return Boolean(getLroMetadata(program, operation.operation));
+}
+
+/**
+ * Return if we have a client-level LRO overloading
+ * @param pathDictionary
+ * @returns
+ */
+export function getClientLroOverload(pathDictionary: Paths) {
+  let lroCounts = 0,
+    allowCounts = 0;
+  for (const details of Object.values(pathDictionary)) {
+    for (const methodDetails of Object.values(details.methods)) {
+      const lroDetail = methodDetails[0].operationHelperDetail?.lroDetails;
+      if (lroDetail?.isLongRunning) {
+        lroCounts++;
+        if (!lroDetail.operationLroOverload) {
+          return false;
         }
+        allowCounts++;
       }
     }
   }
+
+  return Boolean(lroCounts > 0 && lroCounts === allowCounts);
+}
+
+/**
+ * Check if we have an operation-level overloading
+ * @param program
+ * @param operation The operation detail
+ * @param existingResponseTypes auxilary param for current response types
+ * @param existingResponses auxilary param for raw response data
+ * @returns
+ */
+export function getOperationLroOverload(
+  program: Program,
+  operation: HttpOperation,
+  existingResponseTypes?: ResponseTypes,
+  existingResponses?: ResponseMetadata[]
+) {
+  const metadata = getLroMetadata(program, operation.operation);
+  if (!metadata) {
+    return false;
+  }
+  const hasSuccessReturn = existingResponses?.filter((r) =>
+    r.statusCode.startsWith("20")
+  );
+  if (existingResponseTypes?.success || hasSuccessReturn) {
+    return true;
+  }
   return false;
 }
 
-function hasDecorator(type: DecoratedType, name: string): boolean {
-  return type.decorators.find((it) => it.decorator.name === name) !== undefined;
+/**
+ * Extract the operation LRO details
+ * @param program
+ * @param operation Operation detail
+ * @param responsesTypes Calculated response types
+ * @param operationGroupName Operation group name
+ * @returns
+ */
+export function extractOperationLroDetail(
+  program: Program,
+  operation: HttpOperation,
+  responsesTypes: ResponseTypes,
+  operationGroupName: string
+): OperationLroDetail {
+  let logicalResponseTypes: ResponseTypes | undefined;
+
+  let precedence = OPERATION_LRO_LOW_PRIORITY;
+  const operationLroOverload = getOperationLroOverload(
+    program,
+    operation,
+    responsesTypes
+  );
+  if (operationLroOverload) {
+    logicalResponseTypes = {
+      error: responsesTypes.error,
+      success: [
+        getLroLogicalResponseName(operationGroupName, operation.operation.name)
+      ]
+    };
+    const metadata = getLroMetadata(program, operation.operation);
+    precedence =
+      metadata?.finalStep &&
+      metadata?.finalStep.target &&
+      metadata.finalStep.kind === "pollingSuccessProperty" &&
+      metadata?.finalStep?.target?.name === "result"
+        ? OPERATION_LRO_HIGH_PRIORITY
+        : OPERATION_LRO_LOW_PRIORITY;
+  }
+
+  return {
+    isLongRunning: Boolean(getLroMetadata(program, operation.operation)),
+    logicalResponseTypes,
+    operationLroOverload,
+    precedence
+  };
 }
 
 export function hasPollingOperations(