@azure-tools/typespec-ts 0.36.0 → 0.37.0-alpha.20241230.1

package/src/modular/helpers/typeHelpers.ts

@@ -1,272 +1,18 @@
 import {
   SdkBodyParameter,
+  SdkModelPropertyType,
   SdkType
 } from "@azure-tools/typespec-client-generator-core";
-import { Type } from "../modularCodeModel.js";
 
-/**
- * Represents metadata for a given Type to generate the TypeScript equivalent.
- */
-export interface TypeMetadata {
-  name: string;
-  originModule?: string;
-  isRelative?: boolean;
-  nullable?: boolean;
-  modifier?: "Array";
-}
-
-// Mapping of simple types to their TypeScript equivalents.
-const simpleTypeMap: Record<string, TypeMetadata> = {
-  Key: {
-    name: "KeyCredential"
-  },
-  OAuth2: {
-    name: "TokenCredential"
-  },
-  boolean: { name: "boolean" },
-  datetime: { name: "Date" },
-  float: { name: "number" },
-  integer: { name: "number" },
-  "byte-array": { name: "Uint8Array" },
-  string: { name: "string" },
-  any: { name: "Record<string, any>" },
-  unknown: { name: "any" }
-};
-
-function handleAnomymousModelName(type: Type) {
-  let retVal = `{`;
-  for (const prop of type.properties ?? []) {
-    const propName = prop.clientName ?? prop.restApiName ?? "";
-    const propTypeName = getType(prop.type, prop.type.format).name;
-    if (!propName || !propTypeName) {
-      continue;
-    }
-    retVal += `"${propName}"${prop.optional ? "?" : ""}: ${propTypeName};`;
-  }
-
-  retVal += `}`;
-  return retVal;
-}
-
-function handleNullableTypeName(type: {
-  name?: string;
-  nullable?: boolean;
-}): string {
-  if (!type.name) {
-    throw new Error("Unable to process type without name");
-  }
-  let name = type.name;
-
-  if (type.nullable) {
-    name = `(${name} | null)`;
-  }
-
-  return name;
-}
-
-/**
- * Maps a given Type to its TypeScript representation metadata.
- */
-export function getType(type: Type, format?: string): TypeMetadata {
-  // Handle simple type conversions
-  const simpleType = simpleTypeMap[type.type];
-  if (simpleType) {
-    const typeMetadata: TypeMetadata = { ...simpleType };
-    if (isTypeNullable(type)) {
-      typeMetadata.nullable = true;
-      typeMetadata.name = handleNullableTypeName(typeMetadata);
-    }
-    return typeMetadata;
-  }
-
-  switch (type.type) {
-    case "constant":
-      return handleConstantType(type);
-
-    case "enum":
-      return handleEnumType(type);
-
-    case "list":
-      return handleListType(type);
-
-    case "model":
-      return handleModelType(type);
-
-    case "duration":
-      return handleDurationType(type, format);
-
-    case "combined":
-      return handleCombinedType(type);
-
-    case "dict":
-      return handleDictType(type);
-
-    case "never":
-      return { name: "never", nullable: isTypeNullable(type) };
-    default:
-      throw new Error(`Unsupported type ${type.type}`);
-  }
-}
-
-/**
- * Handles the conversion of constant types to TypeScript representation metadata.
- */
-function handleConstantType(type: Type): TypeMetadata {
-  let typeName: string = type.value?.toString() ?? "undefined";
-  if (type.valueType?.type === "string") {
-    typeName = type.value ? `"${type.value}"` : "undefined";
-  }
-  const name = handleNullableTypeName({
-    name: typeName,
-    nullable: isTypeNullable(type)
-  });
-  return { name, nullable: isTypeNullable(type) };
-}
-
-/**
- * Handles the conversion of enum types to TypeScript representation metadata.
- */
-function handleEnumType(type: Type): TypeMetadata {
-  if (!type.name) {
-    const valueType = !type.isFixed
-      ? ((type.values?.[0] as Type).valueType?.type ?? "string") + " | "
-      : "";
-    return {
-      name: `${valueType}${type.values
-        ?.map((e) => {
-          return getType(e as Type).name;
-        })
-        .join(" | ")}`,
-      nullable: isTypeNullable(type)
-    };
-  }
-  const name = handleNullableTypeName({
-    name: type.name,
-    nullable: isTypeNullable(type)
-  });
-  return {
-    name,
-    nullable: isTypeNullable(type),
-    originModule: "models.js"
-  };
+export function isTypeNullable(type: SdkType) {
+  return Boolean(type.kind === "nullable");
 }
 
-export function isTypeNullable(type: Type) {
-  return Boolean(type.tcgcType?.kind === "nullable");
-}
-
-/**
- * Handles the conversion of list types to TypeScript representation metadata.
- */
-function handleListType(type: Type): TypeMetadata {
-  if (!type.elementType) {
-    throw new Error("Unable to process Array with no elementType");
-  }
-
-  const elementTypeMetadata = getType(
-    type.elementType,
-    type.elementType.format
-  );
-
-  let name = `${elementTypeMetadata.name}[]`;
-
-  const isTypeNullable = type.tcgcType?.kind === "nullable";
-
-  if (isTypeNullable) {
-    name = `(${name} | null)`;
-  }
-
-  const listTypeMetadata: TypeMetadata = {
-    name: name,
-    nullable: isTypeNullable,
-    originModule: type.elementType?.type === "model" ? "models.js" : undefined
-  };
-
-  return listTypeMetadata;
-}
-
-/**
- * Handles the conversion of model types to TypeScript representation metadata.
- */
-function handleModelType(type: Type): TypeMetadata {
-  let name = !type.name ? handleAnomymousModelName(type) : type.name;
-  name = handleNullableTypeName({
-    name,
-    nullable: isTypeNullable(type)
-  });
-  return {
-    name,
-    nullable: isTypeNullable(type),
-    originModule: "models.js"
-  };
-}
-
-/**
- * Handles the conversion of duration types to TypeScript representation metadata.
- */
-function handleDurationType(type: Type, format?: string): TypeMetadata {
-  const isFormatSeconds = format === "seconds";
-  let name = isFormatSeconds ? "number" : "string";
-  name = handleNullableTypeName({ name, nullable: isTypeNullable(type) });
-  return {
-    name,
-    nullable: isTypeNullable(type)
-  };
-}
-
-/**
- * Handles the conversion of combined types to TypeScript representation metadata.
- */
-function handleCombinedType(type: Type): TypeMetadata {
-  if (!type.types) {
-    throw new Error("Unable to process combined without combinedTypes");
-  }
-  const name =
-    type.name ??
-    type.types
-      .map((t) => {
-        const sdkType = getType(t, t.format).name;
-        return `${sdkType}`;
-      })
-      .join(" | ");
-  return { name: `(${name})`, nullable: isTypeNullable(type) };
-}
-
-/**
- * Handles the conversion of dict types to TypeScript representation metadata.
- */
-function handleDictType(type: Type): TypeMetadata {
-  if (!type.elementType) {
-    throw new Error("Unable to process dict without elemetType info");
+export function getNullableValidType(type: SdkType): SdkType {
+  if (type.kind === "nullable") {
+    return type.type;
   }
-  if (type.name && type.name !== "Record") {
-    return {
-      name: type.name
-    };
-  }
-  const elementType = getType(type.elementType, type.elementType.format);
-  const elementName = elementType.name;
-  const name = handleNullableTypeName({
-    name: `Record<string, ${elementName}>`,
-    nullable: isTypeNullable(type)
-  });
-  return {
-    name,
-    nullable: isTypeNullable(type)
-  };
-}
-
-/**
- * Generates a TypeScript type representation for a given client name, type, and format.
- */
-export function buildType(clientName?: string, type?: Type, format?: string) {
-  if (!type) {
-    throw new Error("Type should be defined");
-  }
-
-  const typeMetadata = getType(type, format);
-
-  return { name: clientName ?? "", type: typeMetadata.name };
+  return type;
 }
 
 const NumericTypeKinds = [
@@ -299,12 +45,10 @@ export function isDateTimeTypeKind(kind: string): boolean {
   return DateTimeTypeKinds.includes(kind);
 }
 
-export function isCredentialType(type: Type): boolean {
-  const credentialTypes = ["OAuth2", "Key"];
-  return (
-    credentialTypes.includes(type.type) ||
-    (type.type === "combined" && (type.types?.every(isCredentialType) ?? false))
-  );
+export function isCredentialType(
+  type: SdkType | SdkModelPropertyType
+): boolean {
+  return type.kind === "credential";
 }
 
 /**

package/src/modular/interfaces.ts

@@ -1,12 +1,20 @@
-import { OptionalKind, ParameterDeclarationStructure } from "ts-morph";
-import { Parameter } from "./modularCodeModel.js";
+import { RLCOptions } from "@azure-tools/rlc-common";
+import { Project } from "ts-morph";
 
-export interface ClientDetails {
-  name: string;
-  params?: OptionalKind<ParameterDeclarationStructure>[];
-  description: string;
-  baseUrl?: string;
-  credentialsParam?: Parameter;
+export interface ModularOptions {
+  sourceRoot: string;
+  compatibilityMode: boolean;
+  experimentalExtensibleEnums: boolean;
+}
+export interface ModularEmitterOptions {
+  options: RLCOptions;
+  modularOptions: ModularOptions;
+  project: Project;
+}
+
+export interface ModularClientOptions {
+  subfolder?: string;
+  rlcClientName: string;
 }
 
 export interface OperationPathAndDeserDetails {

package/src/modular/serialization/buildDeserializerFunction.ts

@@ -11,7 +11,6 @@ import { toCamelCase, toPascalCase } from "../../utils/casingUtils.js";
 
 import { SdkContext } from "../../utils/interfaces.js";
 import { getResponseMapping } from "../helpers/operationHelpers.js";
-import { getType } from "../buildCodeModel.js";
 import { normalizeModelName } from "../emitModels.js";
 import { NameType } from "@azure-tools/rlc-common";
 import { isAzureCoreErrorType } from "../../utils/modelUtils.js";
@@ -344,11 +343,7 @@ function buildModelTypeDeserializer(
     ? "...item,"
     : "";
 
-  const propertiesStr = getResponseMapping(
-    context,
-    getType(context, type.__raw!),
-    "item"
-  );
+  const propertiesStr = getResponseMapping(context, type, "item");
   const propertiesDeserialization = propertiesStr.filter((p) => p.trim());
 
   const output = [];

package/src/modular/serialization/buildSerializerFunction.ts

@@ -11,7 +11,6 @@ import { toCamelCase, toPascalCase } from "../../utils/casingUtils.js";
 
 import { SdkContext } from "../../utils/interfaces.js";
 import { getRequestModelMapping } from "../helpers/operationHelpers.js";
-import { getType } from "../buildCodeModel.js";
 import { normalizeModelName } from "../emitModels.js";
 import { NameType } from "@azure-tools/rlc-common";
 import { isAzureCoreErrorType } from "../../utils/modelUtils.js";
@@ -339,7 +338,7 @@ function buildModelTypeSerializer(
 
   const { directAssignment, propertiesStr } = getRequestModelMapping(
     context,
-    getType(context, type.__raw!),
+    type,
     "item"
   );
   if (additionalPropertiesSpread) {

package/src/modular/serialization/serializeUtils.ts

@@ -1,4 +1,3 @@
-import { Type } from "../modularCodeModel.js";
 import { getAllAncestors } from "../helpers/operationHelpers.js";
 import {
   SdkModelType,
@@ -26,10 +25,10 @@ export function isSupportedSerializeType(type: SdkType): boolean {
  * 6. nested model i.e. model with property that is a model with one of the above three conditions.
  * If we consider array type, with all the above 6 types as the element types.
  */
-const specialVariantMap = new Map<Type, boolean>();
+const specialVariantMap = new Map<SdkType, boolean>();
 export function isSpecialUnionVariant(
-  t: Type,
-  variantStack: Type[] = []
+  t: SdkType & { isNonExhaustive?: boolean },
+  variantStack: SdkType[] = []
 ): boolean {
   if (variantStack.length <= 0) {
     variantStack.push(t);
@@ -41,40 +40,40 @@ export function isSpecialUnionVariant(
   }
 
   if (
-    t.type === "datetime" ||
-    t.type === "byte-array" ||
-    (t.type === "model" &&
+    t.kind === "utcDateTime" ||
+    t.kind === "bytes" ||
+    (t.kind === "model" &&
       t.properties
         ?.filter((p) => {
           return !(
             variantStack.includes(p.type) ||
             ancestors.includes(p.type) ||
-            (p.type.type === "list" &&
-              p.type.elementType &&
-              (variantStack.includes(p.type.elementType) ||
-                ancestors.includes(p.type.elementType)))
+            (p.type.kind === "array" &&
+              p.type.valueType &&
+              (variantStack.includes(p.type.valueType) ||
+                ancestors.includes(p.type.valueType)))
           );
         })
         ?.some(
           (p) =>
-            p.clientName !== p.restApiName ||
+            (p.kind === "property" && p.name !== p.serializedName) ||
             isSpecialUnionVariant(p.type, [...variantStack, p.type])
         )) ||
     isPolymorphicUnion(t) ||
-    (t.type === "list" &&
-      t.elementType &&
-      !variantStack.includes(t.elementType) &&
-      !ancestors.includes(t.elementType) &&
-      isSpecialUnionVariant(t.elementType, [...variantStack, t.elementType])) ||
-    (t.type === "combined" &&
-      t.types
+    (t.kind === "array" &&
+      t.valueType &&
+      !variantStack.includes(t.valueType) &&
+      !ancestors.includes(t.valueType) &&
+      isSpecialUnionVariant(t.valueType, [...variantStack, t.valueType])) ||
+    (t.kind === "union" &&
+      t.variantTypes
         ?.filter((p) => {
           return !(variantStack.includes(p) || ancestors.includes(p));
         })
         ?.some((p) => {
           return isSpecialUnionVariant(p, [...variantStack, p]);
         })) ||
-    (t.type === "enum" && !(t.isFixed || t.isNonExhaustive))
+    (t.kind === "enum" && !(t.isFixed || t.isNonExhaustive))
   ) {
     specialVariantMap.set(t, true);
     variantStack.pop();
@@ -85,11 +84,11 @@ export function isSpecialUnionVariant(
   return false;
 }
 
-export function isNormalUnion(t: Type): boolean {
+export function isNormalUnion(t: SdkType): boolean {
   return (
-    t.type === "combined" &&
+    t.kind === "union" &&
     !(
-      t.types?.some((p) => {
+      t.variantTypes?.some((p) => {
         return isSpecialUnionVariant(p);
       }) ?? false
     )
@@ -109,20 +108,22 @@ export function isDiscriminatedUnion(
   );
 }
 
-export function isSpecialHandledUnion(t: Type): boolean {
-  return isDiscriminatedUnion(t.tcgcType!) || isPolymorphicUnion(t);
+export function isSpecialHandledUnion(
+  t: SdkType & { isNonExhaustive?: boolean }
+): boolean {
+  return isDiscriminatedUnion(t!) || isPolymorphicUnion(t);
 }
 
-const polymorphicUnionMap = new Map<Type, boolean>();
-export function isPolymorphicUnion(t: Type): boolean {
+const polymorphicUnionMap = new Map<SdkType, boolean>();
+export function isPolymorphicUnion(t: SdkType): boolean {
   if (polymorphicUnionMap.has(t)) {
     return polymorphicUnionMap.get(t) ?? false;
   }
   const ancestors = getAllAncestors(t);
   if (
-    t.type === "model" &&
-    t.isPolymorphicBaseModel &&
-    t.types
+    t.kind === "model" &&
+    t.discriminatedSubtypes &&
+    Object.values(t.discriminatedSubtypes)
       ?.filter((p) => {
         return !ancestors.includes(p);
       })

package/src/utils/clientUtils.ts

@@ -1,6 +1,12 @@
-import { SdkClient } from "@azure-tools/typespec-client-generator-core";
+import {
+  SdkClient,
+  SdkClientType,
+  SdkServiceOperation
+} from "@azure-tools/typespec-client-generator-core";
 import { getNamespaceFullName, listServices } from "@typespec/compiler";
 import { SdkContext } from "./interfaces.js";
+import { NameType, normalizeName } from "@azure-tools/rlc-common";
+import { ModularClientOptions } from "../modular/interfaces.js";
 
 export function getRLCClients(dpgContext: SdkContext): SdkClient[] {
   const services = listServices(dpgContext.program);
@@ -23,3 +29,19 @@ export function getRLCClients(dpgContext: SdkContext): SdkClient[] {
 export function isRLCMultiEndpoint(dpgContext: SdkContext): boolean {
   return getRLCClients(dpgContext).length > 1;
 }
+
+export function getModularClientOptions(
+  context: SdkContext,
+  client: SdkClientType<SdkServiceOperation>
+) {
+  const clientOptions: ModularClientOptions = {
+    rlcClientName: `${client.name.replace("Client", "")}Context`
+  };
+  if (context.sdkPackage.clients.length > 1) {
+    clientOptions.subfolder = normalizeName(
+      client.name.replace("Client", ""),
+      NameType.File
+    );
+  }
+  return clientOptions;
+}

package/src/utils/operationUtil.ts

@@ -23,7 +23,15 @@ import {
   getWireName,
   listOperationGroups,
   listOperationsInOperationGroup,
-  SdkClient
+  SdkBodyParameter,
+  SdkClient,
+  SdkClientType,
+  SdkHttpOperation,
+  SdkHttpParameter,
+  SdkMethod,
+  SdkMethodParameter,
+  SdkServiceMethod,
+  SdkServiceOperation
 } from "@azure-tools/typespec-client-generator-core";
 import { Model, Operation, Program, Type } from "@typespec/compiler";
 import {
@@ -408,6 +416,19 @@ export function extractPagedMetadataNested(
   return paged;
 }
 
+export function hasCollectionFormatInfo(
+  paramType: string,
+  paramFormat: string
+) {
+  return (
+    getHasMultiCollection(paramType, paramFormat) ||
+    getHasSsvCollection(paramType, paramFormat) ||
+    getHasTsvCollection(paramType, paramFormat) ||
+    getHasCsvCollection(paramType, paramFormat) ||
+    getHasPipeCollection(paramType, paramFormat)
+  );
+}
+
 export function getSpecialSerializeInfo(
   dpgContext: SdkContext,
   paramType: string,
@@ -465,19 +486,6 @@ function getHasPipeCollection(paramType: string, paramFormat: string) {
   return paramType === "query" && paramFormat === "pipes";
 }
 
-export function hasCollectionFormatInfo(
-  paramType: string,
-  paramFormat: string
-) {
-  return (
-    getHasMultiCollection(paramType, paramFormat) ||
-    getHasSsvCollection(paramType, paramFormat) ||
-    getHasTsvCollection(paramType, paramFormat) ||
-    getHasCsvCollection(paramType, paramFormat) ||
-    getHasPipeCollection(paramType, paramFormat)
-  );
-}
-
 export function getCollectionFormatHelper(
   paramType: string,
   paramFormat: string
@@ -546,3 +554,87 @@ export function parseItemName(paged: PagedResultMetadata): string | undefined {
   // TODO: support the nested item names
   return (paged.itemsSegments ?? [])[0];
 }
+
+export type ServiceOperation = SdkServiceMethod<SdkHttpOperation> & {
+  oriName?: string;
+};
+
+export function getMethodHierarchiesMap(
+  context: SdkContext,
+  client: SdkClientType<SdkServiceOperation>
+): Map<string, ServiceOperation[]> {
+  const methodQueue: [string[], SdkMethod<SdkHttpOperation>][] =
+    client.methods.map((m) => {
+      return [[], m];
+    });
+  const operationHierarchiesMap: Map<string, ServiceOperation[]> = new Map<
+    string,
+    ServiceOperation[]
+  >();
+  while (methodQueue.length > 0) {
+    const method = methodQueue.pop();
+    if (!method) {
+      continue;
+    }
+    const prefixes = method[0];
+    const operationOrGroup = method[1];
+
+    if (operationOrGroup.kind === "clientaccessor") {
+      operationOrGroup.response.methods.forEach((m) =>
+        methodQueue.push([[...prefixes, operationOrGroup.response.name], m])
+      );
+    } else {
+      const prefixKey =
+        context.rlcOptions?.hierarchyClient ||
+        context.rlcOptions?.enableOperationGroup
+          ? prefixes.join("/")
+          : "";
+      const groupName = prefixes
+        .map((p) => normalizeName(p, NameType.OperationGroup))
+        .join("");
+      if (
+        context.rlcOptions?.hierarchyClient === false &&
+        context.rlcOptions?.enableOperationGroup &&
+        groupName !== "" &&
+        !operationOrGroup.name.startsWith(groupName + "_")
+      ) {
+        (operationOrGroup as ServiceOperation).oriName = operationOrGroup.name;
+        operationOrGroup.name = `${groupName}_${operationOrGroup.name}`;
+      }
+
+      operationOrGroup.parameters.map((p) => {
+        return resolveParameterNameConflict(operationOrGroup, p);
+      });
+      operationOrGroup.operation.parameters.map((p) => {
+        return resolveParameterNameConflict(operationOrGroup, p);
+      });
+      if (
+        operationOrGroup.operation.bodyParam?.name === operationOrGroup.name
+      ) {
+        operationOrGroup.operation.bodyParam = resolveParameterNameConflict(
+          operationOrGroup,
+          operationOrGroup.operation.bodyParam
+        ) as SdkBodyParameter;
+      }
+      const operations = operationHierarchiesMap.get(prefixKey);
+      operationHierarchiesMap.set(prefixKey, [
+        ...(operations ?? []),
+        operationOrGroup
+      ]);
+    }
+  }
+  return operationHierarchiesMap;
+}
+
+function resolveParameterNameConflict(
+  operationOrGroup: SdkServiceMethod<SdkHttpOperation>,
+  p: SdkMethodParameter | SdkHttpParameter | SdkBodyParameter
+): SdkMethodParameter | SdkHttpParameter | SdkBodyParameter {
+  const paramName = normalizeName(p.name, NameType.Parameter, true);
+  if (paramName === operationOrGroup.name) {
+    p.name = `${paramName}Parameter`;
+  } else {
+    p.name = paramName;
+  }
+  return p;
+}

package/dist/src/modular/buildCodeModel.d.ts

@@ -1,34 +0,0 @@
-import { Model, Type, UsageFlags } from "@typespec/compiler";
-import { ModularCodeModel } from "./modularCodeModel.js";
-import { HttpAuth } from "@typespec/http";
-import { RLCModel } from "@azure-tools/rlc-common";
-import { Project } from "ts-morph";
-import { SdkContext } from "../utils/interfaces.js";
-interface CredentialType {
-    kind: "Credential";
-    scheme: HttpAuth;
-}
-interface CredentialTypeUnion {
-    kind: "CredentialTypeUnion";
-    types: CredentialType[];
-}
-type EmitterType = Type | CredentialType | CredentialTypeUnion;
-export interface EmitterOptions {
-    "basic-setup-py"?: boolean;
-    "package-version"?: string;
-    "package-name"?: string;
-    "output-dir"?: string;
-    "package-mode"?: string;
-    debug?: boolean;
-}
-interface EmitTypeOptions {
-    disableEffectiveModel?: boolean;
-    usage?: UsageFlags;
-}
-export declare function getType(context: SdkContext, type: EmitterType, options?: EmitTypeOptions): any;
-export declare function emitModel(context: SdkContext, type: Model, options?: EmitTypeOptions): Record<string, any>;
-export declare function emitCodeModel(dpgContext: SdkContext, rlcModelsMap: Map<string, RLCModel>, modularSourcesRoot: string, project: Project, options?: {
-    casing: "snake" | "camel";
-}): ModularCodeModel;
-export {};
-//# sourceMappingURL=buildCodeModel.d.ts.map