@azure-tools/typespec-ts 0.56.0-dev.1 → 0.56.0-dev.10

package/src/transform/transform-responses.ts

@@ -5,15 +5,14 @@ import { getHttpOperationWithCache, SdkClient } from "@azure-tools/typespec-clie
 import { getDoc, isVoidType } from "@typespec/compiler";
 import { HttpOperation, HttpOperationResponse } from "@typespec/http";
 import {
-  getLroLogicalResponseName,
   Imports,
   OperationResponse,
   ResponseHeaderSchema,
   ResponseMetadata,
   Schema,
   SchemaContext,
-} from "../rlc-common/index.js";
-import { listOperationsUnderRLCClient } from "../utils/client-utils.js";
+} from "../interfaces.js";
+import { listOperationsUnderClient } from "../utils/client-utils.js";
 import { SdkContext } from "../utils/interfaces.js";
 import {
   getBinaryType,
@@ -21,6 +20,7 @@ import {
   getSchemaForType,
   getTypeName,
 } from "../utils/model-utils.js";
+import { getLroLogicalResponseName } from "../utils/name-constructors.js";
 import {
   getOperationGroupName,
   getOperationLroOverload,
@@ -35,9 +35,9 @@ export function transformToResponseTypes(
   dpgContext: SdkContext,
   importDetails: Imports,
 ): OperationResponse[] {
-  const rlcResponses: OperationResponse[] = [];
+  const clientResponses: OperationResponse[] = [];
   const inputImportedSet = new Set<string>();
-  for (const op of listOperationsUnderRLCClient(client)) {
+  for (const op of listOperationsUnderClient(client)) {
     const route = getHttpOperationWithCache(dpgContext, op);
     // ignore overload base operation
     if (route.overloads && route.overloads?.length > 0) {
@@ -49,7 +49,7 @@ export function transformToResponseTypes(
     importDetails.response.importsSet = inputImportedSet;
   }
   function transformToResponseTypesForRoute(route: HttpOperation) {
-    const rlcOperationUnit: OperationResponse = {
+    const operationUnit: OperationResponse = {
       operationGroup: getOperationGroupName(dpgContext, route),
       operationName: getOperationName(dpgContext, route.operation),
       path: route.path,
@@ -59,7 +59,7 @@ export function transformToResponseTypes(
       nonDefaultSchemas: Schema[] = [];
     for (const resp of sortedOperationResponses(route.responses)) {
       const statusCode = getOperationStatuscode(resp);
-      const rlcResponseUnit: ResponseMetadata = {
+      const responseUnit: ResponseMetadata = {
         statusCode,
         description: resp.description,
       };
@@ -67,8 +67,8 @@ export function transformToResponseTypes(
       const headers = transformHeaders(dpgContext, resp, inputImportedSet);
       // transform body
       const [body, schemas] = transformBody(dpgContext, resp, inputImportedSet) ?? [undefined, []];
-      rlcOperationUnit.responses.push({
-        ...rlcResponseUnit,
+      operationUnit.responses.push({
+        ...responseUnit,
         headers,
         body,
       });
@@ -82,20 +82,20 @@ export function transformToResponseTypes(
       dpgContext,
       route,
       getOperationGroupName(dpgContext, route),
-      rlcOperationUnit.responses,
+      operationUnit.responses,
     );
     if (lroLogicalResponse) {
-      rlcOperationUnit.responses.push(lroLogicalResponse);
+      operationUnit.responses.push(lroLogicalResponse);
     }
-    rlcResponses.push(rlcOperationUnit);
+    clientResponses.push(operationUnit);
   }
-  return rlcResponses;
+  return clientResponses;
 }
 
 /**
  * Return undefined if no valid header param
  * @param response response detail
- * @returns rlc header schema
+ * @returns the response header schema
  */
 function transformHeaders(
   dpgContext: SdkContext,
@@ -106,8 +106,8 @@ function transformHeaders(
     return;
   }
 
-  const rlcHeaders: Map<string, ResponseHeaderSchema> = new Map();
-  // Current RLC client can't represent different headers per content type.
+  const responseHeaders: Map<string, ResponseHeaderSchema> = new Map();
+  // The client can't represent different headers per content type.
   // So we merge headers here, and report any duplicates.
   // It may be possible in principle to not error for identically declared
   // headers.
@@ -139,11 +139,11 @@ function transformHeaders(
         required: !value?.optional,
         description: getDoc(dpgContext.program, value!),
       };
-      rlcHeaders.set(header.name, header);
+      responseHeaders.set(header.name, header);
     }
   }
 
-  return rlcHeaders.size ? Array.from(rlcHeaders.values()) : undefined;
+  return responseHeaders.size ? Array.from(responseHeaders.values()) : undefined;
 }
 
 function transformBody(
@@ -154,7 +154,7 @@ function transformBody(
   if (!response.responses.length) {
     return;
   }
-  // Currently RLC response only have one header and body defined
+  // Currently a response only has one header and body defined
   // So we'll union all body shapes together with "|"
   const typeSet = new Set<string>();
   const descriptions = new Set<string>();

package/src/transform/transform-schemas.ts

@@ -15,19 +15,19 @@ import {
 } from "../utils/model-utils.js";
 
 import { useContext } from "../context-manager.js";
-import { SchemaContext } from "../rlc-common/index.js";
-import { listOperationsUnderRLCClient } from "../utils/client-utils.js";
+import { SchemaContext } from "../interfaces.js";
+import { listOperationsUnderClient } from "../utils/client-utils.js";
 import { SdkContext } from "../utils/interfaces.js";
 
 export function transformSchemas(client: SdkClient, dpgContext: SdkContext) {
   const program = dpgContext.program;
-  const metatree = useContext("rlcMetaTree");
+  const metatree = useContext("clientTypeMetaTree");
   const schemas: Map<string, SchemaContext[]> = new Map<string, SchemaContext[]>();
   const schemaMap: Map<any, any> = new Map<any, any>();
   const usageMap = new Map<Type, SchemaContext[]>();
   const requestBodySet = new Set<Type>();
   const contentTypeMap = new Map<Type, KnownMediaType[]>();
-  for (const op of listOperationsUnderRLCClient(client)) {
+  for (const op of listOperationsUnderClient(client)) {
     const route = getHttpOperationWithCache(dpgContext, op);
     // ignore overload base operation
     if (route.overloads && route.overloads?.length > 0) {
@@ -103,7 +103,7 @@ export function transformSchemas(client: SdkClient, dpgContext: SdkContext) {
     if (model) {
       model.usage = context;
     }
-    metatree.set(tspModel, { rlcType: model });
+    metatree.set(tspModel, { clientType: model });
     if (model.name === "") {
       return;
     }

package/src/transform/transform-telemetry-info.ts

@@ -3,8 +3,8 @@ import {
   SdkClient,
   SdkContext,
 } from "@azure-tools/typespec-client-generator-core";
-import { TelemetryInfo } from "../rlc-common/index.js";
-import { listOperationsUnderRLCClient } from "../utils/client-utils.js";
+import { TelemetryInfo } from "../interfaces.js";
+import { listOperationsUnderClient } from "../utils/client-utils.js";
 import { getCustomRequestHeaderNameForOperation } from "../utils/operation-util.js";
 
 export function transformTelemetryInfo(
@@ -21,7 +21,7 @@ export function transformTelemetryInfo(
 }
 
 function getCustomRequestHeaderNameForClient(dpgContext: SdkContext, client: SdkClient) {
-  for (const op of listOperationsUnderRLCClient(client)) {
+  for (const op of listOperationsUnderClient(client)) {
     const headerName = getCustomRequestHeaderNameForOperation(
       getHttpOperationWithCache(dpgContext, op),
     );

package/src/transform/transform.ts

@@ -5,21 +5,18 @@ import { SdkClient } from "@azure-tools/typespec-client-generator-core";
 import { getDoc, joinPaths } from "@typespec/compiler";
 import { getServers } from "@typespec/http";
 import {
-  buildRuntimeImports,
+  ClientModel,
+  ClientOptions,
   Imports,
-  initInternalImports,
-  NameType,
-  normalizeName,
   OperationParameter,
   OperationResponse,
   PathParameter,
   Paths,
-  RLCModel,
-  RLCOptions,
   Schema,
   SchemaContext,
   UrlInfo,
-} from "../rlc-common/index.js";
+} from "../interfaces.js";
+import { buildRuntimeImports, initInternalImports } from "../utils/imports-util.js";
 import { SdkContext } from "../utils/interfaces.js";
 import {
   getDefaultService,
@@ -29,6 +26,7 @@ import {
   getTypeName,
   predictDefaultValue,
 } from "../utils/model-utils.js";
+import { NameType, normalizeName } from "../utils/name-utils.js";
 import { getClientLroOverload } from "../utils/operation-util.js";
 import { transformApiVersionInfo } from "./transform-api-version-info.js";
 import { transformHelperFunctionDetails } from "./transform-helper-function-details.js";
@@ -38,15 +36,15 @@ import { transformToResponseTypes } from "./transform-responses.js";
 import { transformSchemas } from "./transform-schemas.js";
 import { transformTelemetryInfo } from "./transform-telemetry-info.js";
 
-export async function transformRLCModel(
+export async function transformClientModel(
   client: SdkClient,
   dpgContext: SdkContext,
-): Promise<RLCModel> {
+): Promise<ClientModel> {
   const program = dpgContext.program;
-  const options: RLCOptions = dpgContext.rlcOptions!;
-  const rlcSourceDir = dpgContext.generationPathDetail?.rlcSourcesDir;
+  const options: ClientOptions = dpgContext.emitterOptions!;
+  const sourceDir = dpgContext.generationPathDetail?.sourcesDir;
   const srcPath = joinPaths(
-    dpgContext.generationPathDetail?.rlcSourcesDir ?? "",
+    dpgContext.generationPathDetail?.sourcesDir ?? "",
     options.batch && options.batch.length > 1
       ? normalizeName(client.name.replace("Client", ""), NameType.File)
       : "",
@@ -71,7 +69,7 @@ export async function transformRLCModel(
   helperDetails.clientLroOverload = getClientLroOverload(paths);
 
   const telemetryOptions = transformTelemetryInfo(client, dpgContext);
-  const model: RLCModel = {
+  const model: ClientModel = {
     srcPath,
     libraryName,
     paths,
@@ -87,11 +85,8 @@ export async function transformRLCModel(
       internalImports: importSet,
       runtimeImports: buildRuntimeImports(),
     },
-    rlcSourceDir,
+    sourceDir,
   };
-  // RLC sample generation has been removed; modular samples are emitted separately,
-  // so the RLC model never carries sample groups.
-  options.generateSample = false;
   return model;
 }
 
@@ -145,7 +140,7 @@ export function transformUrlInfo(
     }
   }
   if (importedModels.size > 0) {
-    importDetails.rlcClientFactory.importsSet = importedModels;
+    importDetails.clientFactory.importsSet = importedModels;
   }
   if (endpoint && urlParameters.length > 0) {
     for (const param of urlParameters) {

package/src/utils/client-utils.ts

@@ -14,11 +14,11 @@ import {
   Namespace,
   Operation,
 } from "@typespec/compiler";
-import { ModularClientOptions } from "../modular/interfaces.js";
-import { NameType, normalizeName } from "../rlc-common/index.js";
+import { ClientModuleInfo } from "../modular/interfaces.js";
 import { SdkContext } from "./interfaces.js";
+import { NameType, normalizeName } from "./name-utils.js";
 
-export function getRLCClients(dpgContext: SdkContext): SdkClient[] {
+export function getClients(dpgContext: SdkContext): SdkClient[] {
   const clients = listClients(dpgContext);
   const rawServiceNamespaces =
     dpgContext.allServiceNamespaces ?? listAllServiceNamespaces(dpgContext);
@@ -79,7 +79,7 @@ export function getRLCClients(dpgContext: SdkContext): SdkClient[] {
   });
 }
 
-export function listOperationsUnderRLCClient(client: SdkClient): Operation[] {
+export function listOperationsUnderClient(client: SdkClient): Operation[] {
   const operations = [];
   const serviceArray = client.services;
   const queue: (Namespace | Interface)[] = [...serviceArray];
@@ -110,17 +110,17 @@ export function listOperationsUnderRLCClient(client: SdkClient): Operation[] {
   return operations;
 }
 
-export function isRLCMultiEndpoint(dpgContext: SdkContext): boolean {
-  return getRLCClients(dpgContext).length > 1;
+export function isMultiEndpointClient(dpgContext: SdkContext): boolean {
+  return getClients(dpgContext).length > 1;
 }
 
-export function getModularClientOptions(clientMap: [string[], SdkClientType<SdkServiceOperation>]) {
+export function getClientModuleInfo(clientMap: [string[], SdkClientType<SdkServiceOperation>]) {
   const [hierarchy, client] = clientMap;
-  const clientOptions: ModularClientOptions = {
-    rlcClientName: `${client.name.replace(/Client$/, "")}Context`,
+  const clientModuleInfo: ClientModuleInfo = {
+    clientName: `${client.name.replace(/Client$/, "")}Context`,
   };
-  clientOptions.subfolder = hierarchy.join("/");
-  return clientOptions;
+  clientModuleInfo.subfolder = hierarchy.join("/");
+  return clientModuleInfo;
 }
 
 export function getClientHierarchyMap(

package/src/utils/cross-language-def.ts

@@ -3,15 +3,15 @@
 
 import { UsageFlags } from "@azure-tools/typespec-client-generator-core";
 import { transformModularEmitterOptions } from "../modular/build-modular-options.js";
-import { NameType, normalizeName } from "../rlc-common/index.js";
 import { SdkContext } from "./interfaces.js";
+import { NameType, normalizeName } from "./name-utils.js";
 import { getMethodHierarchiesMap } from "./operation-util.js";
 
 export function generateCrossLanguageDefinitionFile(dpgContext: SdkContext): {
   CrossLanguagePackageId: string;
   CrossLanguageDefinitionId: Record<string, string>;
 } {
-  const modularSourcesRoot = dpgContext.generationPathDetail?.modularSourcesDir ?? "src";
+  const modularSourcesRoot = dpgContext.generationPathDetail?.sourcesDir ?? "src";
   const emitterOptions = transformModularEmitterOptions(dpgContext, modularSourcesRoot, {
     casing: "camel",
   });
@@ -24,7 +24,7 @@ export function generateCrossLanguageDefinitionFile(dpgContext: SdkContext): {
   }
   for (const enm of dpgContext.sdkPackage.enums) {
     // Skip api version enum for multi-service scenarios since each service may have different versions
-    if (dpgContext.rlcOptions?.isMultiService && enm.usage === UsageFlags.ApiVersionEnum) {
+    if (dpgContext.emitterOptions?.isMultiService && enm.usage === UsageFlags.ApiVersionEnum) {
       continue;
     }
     CrossLanguageDefinitionId[`${packageName}!Known${enm.name}:enum`] =

package/src/utils/emit-util.ts

@@ -3,20 +3,20 @@ import { format } from "prettier";
 import prettierPluginBabel from "prettier/plugins/babel";
 import prettierPluginEstree from "prettier/plugins/estree";
 import prettierPluginTypescript from "prettier/plugins/typescript";
+import { ClientModel, ContentBuilder, File } from "../interfaces.js";
 import { prettierJSONOptions, prettierTypeScriptOptions, reportDiagnostic } from "../lib.js";
-import { ContentBuilder, File, RLCModel } from "../rlc-common/index.js";
 
 export async function emitContentByBuilder(
   program: Program,
   builderFnOrList: ContentBuilder | ContentBuilder[],
-  rlcModels: RLCModel,
+  clientModels: ClientModel,
   emitterOutputDir?: string,
 ) {
   if (!Array.isArray(builderFnOrList)) {
     builderFnOrList = [builderFnOrList];
   }
   for (const builderFn of builderFnOrList) {
-    let contentFiles: File[] | File | undefined = builderFn(rlcModels);
+    let contentFiles: File[] | File | undefined = builderFn(clientModels);
     if (!contentFiles) {
       continue;
     }

package/src/{rlc-common/helpers → utils}/imports-util.ts

@@ -63,20 +63,20 @@ export function initInternalImports(): Imports {
       type: "response",
       importsSet: new Set<string>(),
     },
-    rlcIndex: {
-      type: "rlcIndex",
+    index: {
+      type: "index",
       importsSet: new Set<string>(),
     },
     modularModel: {
       type: "modularModel",
       importsSet: new Set<string>(),
     },
-    rlcClientFactory: {
-      type: "rlcClientFactory",
+    clientFactory: {
+      type: "clientFactory",
       importsSet: new Set<string>(),
     },
-    rlcClientDefinition: {
-      type: "rlcClientDefinition",
+    clientDefinition: {
+      type: "clientDefinition",
       importsSet: new Set<string>(),
     },
     serializerHelpers: {

package/src/utils/interfaces.ts

@@ -1,10 +1,10 @@
 import { SdkContext as TCGCSdkContext } from "@azure-tools/typespec-client-generator-core";
 import { ModelProperty, Namespace } from "@typespec/compiler";
-import { RLCOptions, SchemaContext } from "../rlc-common/index.js";
+import { ClientOptions, SchemaContext } from "../interfaces.js";
 import { KnownMediaType } from "./media-types.js";
 
 export interface SdkContext extends TCGCSdkContext {
-  rlcOptions?: RLCOptions;
+  emitterOptions?: ClientOptions;
   generationPathDetail?: GenerationDirDetail;
   hasApiVersionInClient?: boolean;
   allServiceNamespaces?: Namespace[];
@@ -12,8 +12,7 @@ export interface SdkContext extends TCGCSdkContext {
 
 export interface GenerationDirDetail {
   rootDir: string;
-  rlcSourcesDir: string;
-  modularSourcesDir?: string;
+  sourcesDir: string;
   metadataDir: string;
 }
 

package/src/utils/model-utils.ts

@@ -64,21 +64,20 @@ import {
   isBody,
   isStatusCode,
 } from "@typespec/http";
+import { GetSchemaOptions, SdkContext } from "./interfaces.js";
+import { KnownMediaType, hasMediaType, isMediaTypeMultipartFormData } from "./media-types.js";
+
 import {
   ArraySchema,
   DictionarySchema,
-  NameType,
   ObjectSchema,
   Schema,
   SchemaContext,
-  isArraySchema,
-  normalizeName,
-} from "../rlc-common/index.js";
-import { GetSchemaOptions, SdkContext } from "./interfaces.js";
-import { KnownMediaType, hasMediaType, isMediaTypeMultipartFormData } from "./media-types.js";
-
+} from "../interfaces.js";
 import { reportDiagnostic } from "../lib.js";
+import { NameType, normalizeName } from "./name-utils.js";
 import { getModelNamespaceName } from "./namespace-utils.js";
+import { isArraySchema } from "./schema-helpers.js";
 
 export const BINARY_TYPE_UNION =
   "string | Uint8Array | ReadableStream<Uint8Array> | NodeReadableStream";
@@ -859,7 +858,7 @@ function getModelName(dpgContext: SdkContext, model: Model) {
     fullNamespacePrefix = "";
   }
   // 5. check if this model should be namespaced
-  return dpgContext.rlcOptions?.enableModelNamespace ? `${fullNamespacePrefix}${name}` : name;
+  return dpgContext.emitterOptions?.enableModelNamespace ? `${fullNamespacePrefix}${name}` : name;
 }
 
 // Map an typespec type to an OA schema. Returns undefined when the resulting

package/src/{rlc-common/helpers → utils}/name-constructors.ts

@@ -1,7 +1,7 @@
 // Copyright (c) Microsoft Corporation.
 // Licensed under the MIT License.
 
-import { RLCModel } from "../interfaces.js";
+import { ClientModel } from "../interfaces.js";
 import { NameType, normalizeName } from "./name-utils.js";
 
 /**
@@ -76,7 +76,7 @@ export function getParameterTypeName(baseNameOrOperationGroup: string, operation
   return normalizeName(`${baseNameOrOperationGroup}_Parameters`, NameType.Interface);
 }
 
-export function getClientName(model: RLCModel) {
+export function getClientName(model: ClientModel) {
   return model.libraryName;
 }
 

package/src/utils/namespace-utils.ts

@@ -22,15 +22,15 @@ export function getOperationNamespaceInterfaceName(
 ): string[] {
   const result: string[] = [];
   if (
-    dpgContext.rlcOptions?.hierarchyClient === false &&
-    dpgContext.rlcOptions?.enableOperationGroup !== true
+    dpgContext.emitterOptions?.hierarchyClient === false &&
+    dpgContext.emitterOptions?.enableOperationGroup !== true
   ) {
     return result;
   }
   if (operation.interface) {
     if (
-      dpgContext.rlcOptions?.enableOperationGroup === true &&
-      dpgContext.rlcOptions?.hierarchyClient === false
+      dpgContext.emitterOptions?.enableOperationGroup === true &&
+      dpgContext.emitterOptions?.hierarchyClient === false
     ) {
       result.push(operation.interface.name);
       return result;

package/src/{rlc-common/helpers → utils}/operation-helpers.ts

@@ -3,11 +3,11 @@
 
 import { MethodSignatureStructure, OptionalKind, ParameterDeclarationStructure } from "ts-morph";
 import {
+  ClientModel,
   Methods,
   ObjectSchema,
   ParameterMetadata,
   PathParameter,
-  RLCModel,
   Schema,
   SchemaContext,
 } from "../interfaces.js";
@@ -59,35 +59,35 @@ export function getPathParamDefinitions(
   });
 }
 
-export function hasPagingOperations(model: RLCModel) {
+export function hasPagingOperations(model: ClientModel) {
   return Boolean(model.helperDetails?.hasPaging);
 }
 
-export function hasPollingOperations(model: RLCModel) {
+export function hasPollingOperations(model: ClientModel) {
   return Boolean(model.helperDetails?.hasLongRunning);
 }
 
-export function hasMultiCollection(model: RLCModel) {
+export function hasMultiCollection(model: ClientModel) {
   return Boolean(model.helperDetails?.hasMultiCollection);
 }
 
-export function hasPipeCollection(model: RLCModel) {
+export function hasPipeCollection(model: ClientModel) {
   return Boolean(model.helperDetails?.hasPipeCollection);
 }
 
-export function hasSsvCollection(model: RLCModel) {
+export function hasSsvCollection(model: ClientModel) {
   return Boolean(model.helperDetails?.hasSsvCollection);
 }
 
-export function hasTsvCollection(model: RLCModel) {
+export function hasTsvCollection(model: ClientModel) {
   return Boolean(model.helperDetails?.hasTsvCollection);
 }
 
-export function hasCsvCollection(model: RLCModel) {
+export function hasCsvCollection(model: ClientModel) {
   return Boolean(model.helperDetails?.hasCsvCollection);
 }
 
-export function hasUnexpectedHelper(model: RLCModel) {
+export function hasUnexpectedHelper(model: ClientModel) {
   const pathDictionary = model.paths;
   for (const details of Object.values(pathDictionary)) {
     for (const methodDetails of Object.values(details.methods)) {
@@ -106,14 +106,14 @@ export function hasUnexpectedHelper(model: RLCModel) {
   return false;
 }
 
-export function hasInputModels(model: RLCModel) {
+export function hasInputModels(model: ClientModel) {
   return hasSchemaContextObject(model, [SchemaContext.Input]);
 }
-export function hasOutputModels(model: RLCModel) {
+export function hasOutputModels(model: ClientModel) {
   return hasSchemaContextObject(model, [SchemaContext.Output, SchemaContext.Exception]);
 }
 
-function hasSchemaContextObject(model: RLCModel, schemaUsage: SchemaContext[]) {
+function hasSchemaContextObject(model: ClientModel, schemaUsage: SchemaContext[]) {
   const objectSchemas: ObjectSchema[] = (model.schemas ?? []).filter(
     (o) => isObjectSchema(o) && (o as ObjectSchema).usage?.some((u) => schemaUsage.includes(u)),
   );