@azure-tools/typespec-ts 0.29.0 → 0.30.0

package/src/modular/buildClientContext.ts

@@ -1,20 +1,20 @@
+import {
+  getImportSpecifier,
+  NameType,
+  normalizeName
+} from "@azure-tools/rlc-common";
 import { SourceFile } from "ts-morph";
+import { isRLCMultiEndpoint } from "../utils/clientUtils.js";
+import { SdkContext } from "../utils/interfaces.js";
+import { importModels } from "./buildOperations.js";
 import {
   getClientParameters,
   importCredential
 } from "./helpers/clientHelpers.js";
-import { getClientName } from "./helpers/namingHelpers.js";
-import { Client, ModularCodeModel } from "./modularCodeModel.js";
-import { isRLCMultiEndpoint } from "../utils/clientUtils.js";
 import { getDocsFromDescription } from "./helpers/docsHelpers.js";
-import { importModels } from "./buildOperations.js";
-import { SdkContext } from "../utils/interfaces.js";
-import {
-  getImportSpecifier,
-  normalizeName,
-  NameType
-} from "@azure-tools/rlc-common";
+import { getClientName } from "./helpers/namingHelpers.js";
 import { getType } from "./helpers/typeHelpers.js";
+import { Client, ModularCodeModel } from "./modularCodeModel.js";
 
 /**
  * This function creates the file containing the modular client context
@@ -26,7 +26,7 @@ export function buildClientContext(
 ): SourceFile {
   const { description, subfolder } = client;
   const name = getClientName(client);
-  const params = getClientParameters(client);
+  const params = getClientParameters(client, dpgContext);
   const srcPath = codeModel.modularOptions.sourceRoot;
   const clientContextFile = codeModel.project.createSourceFile(
     `${srcPath}/${

package/src/modular/buildCodeModel.ts

@@ -1,84 +1,87 @@
 import {
-  getPagedResult,
-  getLroMetadata
+  buildRuntimeImports,
+  getClientName,
+  NameType,
+  normalizeName,
+  RLCModel
+} from "@azure-tools/rlc-common";
+import {
+  getLroMetadata,
+  getPagedResult
 } from "@azure-tools/typespec-azure-core";
+import {
+  getAllModels,
+  getClientNamespaceString,
+  getClientType,
+  getDefaultApiVersion,
+  getLibraryName,
+  getSdkBuiltInType,
+  getSdkUnion,
+  getWireName,
+  isApiVersion,
+  listClients,
+  listOperationGroups,
+  listOperationsInOperationGroup,
+  SdkBuiltInType,
+  SdkClient,
+  SdkEnumValueType,
+  SdkType
+} from "@azure-tools/typespec-client-generator-core";
 import {
   Enum,
+  getDiscriminator,
   getDoc,
+  getEncode,
   getFriendlyName,
+  getMaxItems,
   getMaxLength,
   getMaxValue,
+  getMinItems,
   getMinLength,
   getMinValue,
   getPattern,
+  getPropertyType,
   getSummary,
   getVisibility,
   ignoreDiagnostics,
+  IntrinsicScalarName,
+  IntrinsicType,
   isErrorModel,
   isNeverType,
+  isNullType,
+  isNumericType,
+  isStringType,
+  isTemplateDeclarationOrInstance,
+  isType,
+  isVoidType,
+  listServices,
   Model,
   ModelProperty,
   Namespace,
-  Program,
-  getDiscriminator,
   Operation,
+  Program,
   Scalar,
-  IntrinsicScalarName,
-  isStringType,
-  getPropertyType,
-  isNumericType,
-  getMinItems,
-  getMaxItems,
-  listServices,
-  Union,
   Type,
-  IntrinsicType,
-  isNullType,
-  getEncode,
-  isTemplateDeclarationOrInstance,
-  UsageFlags,
-  isVoidType
+  Union,
+  UsageFlags
 } from "@typespec/compiler";
 import {
   getAuthentication,
+  getHttpOperation,
   getServers,
   HttpAuth,
+  HttpOperation,
   HttpOperationParameter,
   HttpOperationResponse,
   HttpOperationResponseContent,
   HttpServer,
-  HttpOperation,
-  getHttpOperation,
   isSharedRoute
 } from "@typespec/http";
 import { getAddedOnVersions } from "@typespec/versioning";
-import {
-  SdkClient,
-  listClients,
-  listOperationGroups,
-  listOperationsInOperationGroup,
-  isApiVersion,
-  getDefaultApiVersion,
-  getClientNamespaceString,
-  getSdkUnion,
-  getAllModels,
-  SdkBuiltInType,
-  getSdkBuiltInType,
-  SdkEnumValueType,
-  getLibraryName,
-  getWireName
-} from "@azure-tools/typespec-client-generator-core";
-import {
-  ModularCodeModel,
-  Client as HrlcClient,
-  Parameter,
-  Operation as HrlcOperation,
-  OperationGroup,
-  Response,
-  Type as HrlcType,
-  Header,
-  Property
-} from "./modularCodeModel.js";
+import { Project } from "ts-morph";
+import { reportDiagnostic } from "../lib.js";
+import { camelToSnakeCase, toCamelCase } from "../utils/casingUtils.js";
+import { SdkContext } from "../utils/interfaces.js";
 import {
   buildCoreTypeInfo,
   getBodyType,
@@ -87,14 +90,9 @@ import {
   isAzureCoreErrorType,
   isSchemaProperty
 } from "../utils/modelUtils.js";
-import { camelToSnakeCase, toCamelCase } from "../utils/casingUtils.js";
-import {
-  RLCModel,
-  getClientName,
-  NameType,
-  normalizeName
-} from "@azure-tools/rlc-common";
+import { getModelNamespaceName } from "../utils/namespaceUtils.js";
 import {
+  extractPagedMetadataNested,
   getOperationGroupName,
   getOperationName,
   isBinaryPayload,
@@ -103,13 +101,20 @@ import {
   parseItemName,
   parseNextLinkName
 } from "../utils/operationUtil.js";
-import { SdkContext } from "../utils/interfaces.js";
-import { Project } from "ts-morph";
-import { buildRuntimeImports } from "@azure-tools/rlc-common";
-import { getModelNamespaceName } from "../utils/namespaceUtils.js";
-import { reportDiagnostic } from "../lib.js";
-import { getType as getTypeName } from "./helpers/typeHelpers.js";
 import { isModelWithAdditionalProperties } from "./emitModels.js";
+import { getType as getTypeName } from "./helpers/typeHelpers.js";
+import {
+  Client as HrlcClient,
+  Header,
+  ModularCodeModel,
+  Operation as HrlcOperation,
+  OperationGroup,
+  Parameter,
+  Property,
+  Response,
+  Type as HrlcType
+} from "./modularCodeModel.js";
+import { useContext } from "../contextManager.js";
 
 interface HttpServerParameter {
   type: "endpointPath";
@@ -305,6 +310,8 @@ function getType(
   type: EmitterType,
   options: { disableEffectiveModel?: boolean; usage?: UsageFlags } = {}
 ): any {
+  const modularMetatree = useContext("modularMetaTree");
+
   // don't cache simple type(string, int, etc) since decorators may change the result
   const enableCache = !isSimpleType(context.program, type);
   const effectiveModel =
@@ -319,6 +326,7 @@ function getType(
     }
   }
   let newValue: any;
+
   if (isEmptyAnonymousModel(type)) {
     // do not generate model for empty model, treat it as any
     newValue = { type: "any" };
@@ -329,6 +337,12 @@ function getType(
     newValue = applyEncoding(context.program, type, newValue);
   }
 
+  if (isTypespecType(type)) {
+    newValue.tcgcType = getClientType(context, type);
+    newValue.__raw = type;
+    modularMetatree.set(type, newValue);
+  }
+
   if (enableCache) {
     if (!options.disableEffectiveModel) {
       typesMap.set(effectiveModel, newValue);
@@ -349,7 +363,8 @@ function getType(
       }
     }
   } else {
-    const key = JSON.stringify(newValue);
+    const { __raw, tcgcType, ...keyableValue } = newValue;
+    const key = JSON.stringify(keyableValue);
     const value = simpleTypesMap.get(key);
     if (value) {
       newValue = value;
@@ -370,9 +385,14 @@ function getType(
       target: type
     });
   }
+
   return newValue;
 }
 
+function isTypespecType(type: EmitterType): type is Type {
+  return type.kind !== "Credential" && type.kind !== "CredentialTypeUnion";
+}
+
 // To pass the yaml dump
 function getAddedOnVersion(p: Program, t: Type): string | undefined {
   return getAddedOnVersions(p, t)?.[0]?.value;
@@ -386,6 +406,7 @@ type ParamBase = {
   restApiName: string;
   inOverload: boolean;
   format?: string;
+  tcgcType: SdkType;
 };
 function emitParamBase(
   context: SdkContext,
@@ -425,7 +446,8 @@ function emitParamBase(
     clientName: applyCasing(name, { casing: CASING }),
     restApiName,
     inOverload: false,
-    format
+    format,
+    tcgcType: getClientType(context, parameter)
   };
 }
 
@@ -440,26 +462,33 @@ type BodyParameter = ParamBase & {
 function emitBodyParameter(
   context: SdkContext,
   httpOperation: HttpOperation
-): BodyParameter {
+): BodyParameter | undefined {
   const params = httpOperation.parameters;
   const body = params.body!;
-  const base = emitParamBase(context, body.parameter ?? body.type);
-  let contentTypes = body.contentTypes;
-  if (contentTypes.length === 0) {
-    contentTypes = ["application/json"];
-  }
-  const type = getType(context, getBodyType(context.program, httpOperation)!, {
-    disableEffectiveModel: true,
-    usage: UsageFlags.Input
-  });
+  if (body.bodyKind === "single") {
+    const base = emitParamBase(context, body.parameter ?? body.type);
+    let contentTypes = body.contentTypes;
+    if (contentTypes.length === 0) {
+      contentTypes = ["application/json"];
+    }
+    const type = getType(
+      context,
+      getBodyType(context.program, httpOperation)!,
+      {
+        disableEffectiveModel: true,
+        usage: UsageFlags.Input
+      }
+    );
 
-  return {
-    contentTypes,
-    type,
-    location: "body",
-    ...base,
-    isBinaryPayload: isBinaryPayload(context, body.type, contentTypes)
-  };
+    return {
+      contentTypes,
+      type,
+      location: "body",
+      ...base,
+      isBinaryPayload: isBinaryPayload(context, body.type, contentTypes)
+    };
+  }
+  return undefined;
 }
 
 function emitParameter(
@@ -481,7 +510,7 @@ function emitParameter(
     clientDefaultValue = type["value"];
     type = type["valueType"];
   }
-  const paramMap: any = {
+  const paramMap = {
     restApiName: parameter.name,
     location: parameter.type,
     type: base.format ? { ...type, format: base.format } : type,
@@ -503,7 +532,7 @@ function emitParameter(
       getServiceNamespace(context.program)
     );
     paramMap.implementation = implementation;
-    paramMap.in_docstring = false;
+    (paramMap as any).in_docstring = false;
     if (defaultApiVersion) {
       clientDefaultValue = defaultApiVersion.value;
     }
@@ -511,7 +540,7 @@ function emitParameter(
       clientDefaultValue = getDefaultApiVersionString(context);
     }
     if (clientDefaultValue !== undefined) {
-      paramMap.optional = true;
+      (paramMap as any).optional = true;
     }
   }
   return { clientDefaultValue, ...base, ...paramMap };
@@ -943,7 +972,7 @@ function getName(program: Program, type: Model): string {
     ) {
       return (
         type.name +
-        type.templateMapper.args
+        (type.templateMapper.args.filter((it) => isType(it)) as Type[])
           .map((it) => (it.kind === "Model" ? it.name : ""))
           .join("")
       );
@@ -993,7 +1022,7 @@ function emitModel(
     getPagedResult(context.program, type)
   ) {
     modelName =
-      type.templateMapper.args
+      (type.templateMapper.args.filter((it) => isType(it)) as Type[])
         .map((it) => {
           switch (it.kind) {
             case "Model":
@@ -1007,9 +1036,11 @@ function emitModel(
         .join("") + "List";
   }
 
+  const page = extractPagedMetadataNested(context.program, type);
+  const isPaging = page && page.itemsSegments && page.itemsSegments.length > 0;
   return {
     type: "model",
-    name: modelName,
+    name: `${isPaging ? "_" : ""}${modelName}`,
     description: getDocStr(context.program, type),
     parents: baseModel ? [baseModel] : [],
     discriminatedSubtypes: [],
@@ -1046,13 +1077,17 @@ function emitEnum(context: SdkContext, type: Enum): Record<string, any> {
     });
   }
 
+  const name = normalizeName(
+    getLibraryName(context, type) ? getLibraryName(context, type) : type.name,
+    NameType.Interface
+  );
   return {
     type: "enum",
-    name: normalizeName(
-      getLibraryName(context, type) ? getLibraryName(context, type) : type.name,
-      NameType.Interface
-    ),
-    description: getDocStr(program, type),
+    name,
+    description:
+      getDocStr(program, type) === ""
+        ? `Type of ${name}`
+        : getDocStr(program, type),
     valueType: { type: enumMemberType(type.members.values().next().value) },
     values: enumValues,
     isFixed: true,
@@ -1322,7 +1357,11 @@ function emitUnion(
   type: Union,
   usage: UsageFlags
 ): Record<string, any> {
-  const sdkType = getSdkUnion(context, type);
+  let sdkType = getSdkUnion(context, type);
+  const isNull = false;
+  if (sdkType.kind === "nullable") {
+    sdkType = sdkType.type;
+  }
   const nonNullOptions = getNonNullOptions(type);
   if (sdkType === undefined) {
     throw Error("Should not have an empty union");
@@ -1346,7 +1385,7 @@ function emitUnion(
       ? normalizeName(unionName, NameType.Interface)
       : undefined;
     return {
-      nullable: sdkType.nullable,
+      nullable: isNull,
       name: unionTypeName,
       description: `Type of ${unionTypeName}`,
       internal: true,
@@ -1360,7 +1399,8 @@ function emitUnion(
       aliasType:
         unionName === "" || unionName === undefined
           ? undefined
-          : variantTypes.map((x) => getTypeName(x).name).join(" | ")
+          : variantTypes.map((x) => getTypeName(x).name).join(" | "),
+      tcgcType: sdkType
     };
   } else if (sdkType.kind === "enum") {
     let typeName = getLibraryName(context, type)
@@ -1373,25 +1413,26 @@ function emitUnion(
       : undefined;
     return {
       name: typeName,
-      nullable: sdkType.nullable,
+      nullable: isNull,
       description: sdkType.description || `Type of ${typeName}`,
       internal: true,
       type: sdkType.kind,
       valueType: emitSimpleType(context, sdkType.valueType as SdkBuiltInType),
       values: sdkType.values.map((x) => emitEnumMember(context, x)),
       isFixed: sdkType.isFixed,
+      isNonExhaustive: context.rlcOptions?.experimentalExtensibleEnums ?? false,
       xmlMetadata: {},
       usage
     };
   } else if (nonNullOptions.length === 1 && nonNullOptions[0]) {
     return {
       ...emitType(context, nonNullOptions[0], usage),
-      nullable: sdkType.nullable
+      nullable: isNull
     };
   } else {
     return {
       ...emitType(context, sdkType.__raw!, usage),
-      nullable: sdkType.nullable
+      nullable: isNull
     };
   }
 }
@@ -1428,7 +1469,7 @@ function emitSimpleType(
   }
 
   return {
-    nullable: sdkType.nullable,
+    nullable: isNullType(sdkType.__raw!),
     type: sdkType.kind === "string" ? "string" : "number", // TODO: handle other types
     doc: "",
     apiVersions: [],
@@ -1814,7 +1855,9 @@ export function emitCodeModel(
     options: dpgContext.rlcOptions ?? {},
     modularOptions: {
       sourceRoot: modularSourcesRoot,
-      compatibilityMode: !!dpgContext.rlcOptions?.compatibilityMode
+      compatibilityMode: !!dpgContext.rlcOptions?.compatibilityMode,
+      experimentalExtensibleEnums:
+        !!dpgContext.rlcOptions?.experimentalExtensibleEnums
     },
     namespace: clientNamespaceString,
     subnamespaceToClients: {},
@@ -1830,7 +1873,6 @@ export function emitCodeModel(
   for (const model of allModels) {
     getType(dpgContext, model.__raw!, { usage: model.usage as UsageFlags });
   }
-
   for (const namespace of getNamespaces(dpgContext)) {
     if (namespace === clientNamespaceString) {
       codeModel.clients = emitClients(dpgContext, namespace, rlcModelsMap);

package/src/modular/buildHelperSerializers.ts

@@ -0,0 +1,71 @@
+import { Project } from "ts-morph";
+import { useContext } from "../contextManager.js";
+const serializeRecordFunction = {
+  symbol: "serializeRecord",
+  content: `
+export function serializeRecord<
+  T extends string | number | boolean | Date | null,
+  R
+>(item: Record<string, T>): Record<string, R>;
+export function serializeRecord<T, R>(
+  item: Record<string, T>,
+  serializer: (item: T) => R
+): Record<string, R>;
+export function serializeRecord<T, R>(
+  item: Record<string, T>,
+  serializer?: (item: T) => R
+): Record<string, R> {
+  return Object.keys(item).reduce(
+    (acc, key) => {
+      if (isSupportedRecordType(item[key])) {
+        acc[key] = item[key] as any;
+      } else if (serializer) {
+        const value = item[key];
+        if (value !== undefined) {
+          acc[key] = serializer(value);
+        }
+      } else {
+        console.warn(\`Don't know how to serialize \${item[key]}\`);
+        acc[key] = item[key] as any;
+      }
+      return acc;
+    },
+    {} as Record<string, R>
+  );
+}`
+};
+const isRecordElementSupportedFunction = {
+  symbol: "isSupportedRecordType",
+  content: `
+function isSupportedRecordType(t: any) {
+  return ["number", "string", "boolean", "null"].includes(typeof t) || t instanceof Date;
+}
+`
+};
+
+export function emitSerializerHelpersFile(
+  project: Project,
+  srcPath: string = "src"
+) {
+  const symbolMap = useContext("symbolMap");
+  const sourceFile = project.createSourceFile(
+    `${srcPath}/helpers/serializerHelpers.ts`,
+    "",
+    {
+      overwrite: true
+    }
+  );
+
+  if (!symbolMap.has(serializeRecordFunction.symbol)) {
+    symbolMap.set(serializeRecordFunction.symbol, sourceFile);
+  }
+
+  if (!symbolMap.has(isRecordElementSupportedFunction.symbol)) {
+    symbolMap.set(isRecordElementSupportedFunction.symbol, sourceFile);
+  }
+
+  sourceFile.addStatements([
+    serializeRecordFunction.content,
+    isRecordElementSupportedFunction.content
+  ]);
+}