@azure-tools/typespec-ts 0.46.1 → 0.47.0-alpha.20251208.1

package/src/modular/serialization/buildSerializerFunction.ts

@@ -2,6 +2,7 @@ import { FunctionDeclarationStructure, StructureKind } from "ts-morph";
 import {
   SdkArrayType,
   SdkDictionaryType,
+  SdkModelPropertyType,
   SdkModelType,
   SdkType,
   SdkUnionType,
@@ -40,17 +41,53 @@ import {
 } from "../helpers/typeHelpers.js";
 import { reportDiagnostic } from "../../lib.js";
 import { NoTarget } from "@typespec/compiler";
+import { useContext } from "../../contextManager.js";
+
+export function buildPropertySerializer(
+  context: SdkContext,
+  property: SdkModelPropertyType,
+  options: ModelSerializeOptions = {
+    nameOnly: false,
+    skipDiscriminatedUnionSuffix: false
+  }
+) {
+  const propertyContext =
+    useContext("sdkTypes").flattenProperties.get(property);
+  // only build de-serializer for flatten property
+  if (property.flatten !== true || !propertyContext) {
+    return undefined;
+  }
+  const predefinedName = `_${normalizeName(
+    `${propertyContext.baseModel.name}_${property.name}`,
+    NameType.Method,
+    true
+  )}Serializer`;
+  return buildModelSerializer(context, property.type, {
+    ...options,
+    flatten: {
+      baseModel: propertyContext.baseModel,
+      property
+    },
+    overrides: {
+      allOptional: property.optional,
+      propertyRenames: propertyContext.conflictMap
+    },
+    predefinedName
+  });
+}
 
 export function buildModelSerializer(
   context: SdkContext,
   type: SdkType,
-  skipDiscriminatedUnion = false,
-  nameOnly: boolean = false
+  options: ModelSerializeOptions = {
+    nameOnly: false,
+    skipDiscriminatedUnionSuffix: false
+  }
 ): FunctionDeclarationStructure | undefined | string {
-  // const modelTcgcType = getTcgcType(type) as SdkModelType;
   if (!isSupportedSerializeType(type)) {
     return undefined;
   }
+  const { nameOnly } = options;
   if (type.kind === "model" || type.kind === "union" || type.kind === "enum") {
     if (
       !type.usage ||
@@ -80,16 +117,13 @@ export function buildModelSerializer(
     return buildPolymorphicSerializer(context, type, nameOnly);
   }
 
-  if (isDiscriminatedUnion(type) && !skipDiscriminatedUnion) {
+  if (isDiscriminatedUnion(type) && !options.skipDiscriminatedUnionSuffix) {
     return buildDiscriminatedUnionSerializer(context, type, nameOnly);
   }
 
   switch (type.kind) {
     case "model":
-      return buildModelTypeSerializer(context, type, {
-        nameOnly,
-        skipDiscriminatedUnionSuffix: skipDiscriminatedUnion
-      });
+      return buildModelTypeSerializer(context, type, options);
     case "union": // for non-discriminated union, we just return whatever we get
       return buildUnionSerializer(context, type, nameOnly);
     case "dict":
@@ -227,6 +261,7 @@ function buildDiscriminatedUnionSerializer(
   if (nameOnly) {
     return resolveReference(refkey(type, "serializer"));
   }
+  // Get the base serializer name and ensure reference tracking
   const baseSerializerName = `${normalizeModelName(
     context,
     type,
@@ -248,12 +283,17 @@ function buildDiscriminatedUnionSerializer(
       type.discriminatorProperty
     );
     const union = subType.discriminatedSubtypes ? "Union" : "";
-    const subTypeName = `${normalizeName(subType.name, NameType.Interface, true)}${union}`;
-    const subtypeSerializerName = normalizeName(
-      `${subTypeName}Serializer`,
-      NameType.Method,
-      true
+    const subTypeName = normalizeModelName(
+      context,
+      subType,
+      NameType.Interface,
+      !union
     );
+    // Get the serializer name and ensure reference tracking
+    const subtypeSerializerName = buildModelSerializer(context, subType, {
+      nameOnly: true,
+      skipDiscriminatedUnionSuffix: false
+    }) as string;
 
     const caseLabels = discriminatedValues.map((value) => `case "${value}":`);
     cases.push(`
@@ -345,14 +385,18 @@ function buildModelTypeSerializer(
     });
     return ""; // Return empty string to continue processing
   }
-  const serializerFunctionName = `${normalizeModelName(
-    context,
-    type,
-    NameType.Operation,
-    options.skipDiscriminatedUnionSuffix
-  )}Serializer`;
+  const serializerFunctionName =
+    options.predefinedName ??
+    `${normalizeModelName(
+      context,
+      type,
+      NameType.Operation,
+      options.skipDiscriminatedUnionSuffix
+    )}Serializer`;
   if (options.nameOnly) {
-    return resolveReference(refkey(type, "serializer"));
+    return options.flatten
+      ? resolveReference(refkey(options.flatten.property, "serializer"))
+      : resolveReference(refkey(type, "serializer"));
   }
   const serializerFunction: FunctionDeclarationStructure = {
     kind: StructureKind.Function,
@@ -361,7 +405,9 @@ function buildModelTypeSerializer(
     parameters: [
       {
         name: "item",
-        type: resolveReference(refkey(type))
+        type: options.flatten
+          ? resolveReference(refkey(options.flatten.baseModel))
+          : resolveReference(refkey(type))
       }
     ],
     returnType: "any",
@@ -435,7 +481,13 @@ function buildModelTypeSerializer(
       type
     );
 
-    const propertiesStr = getRequestModelMapping(context, type, "item");
+    const propertiesStr = getRequestModelMapping(
+      context,
+      type,
+      "item",
+      options.overrides,
+      !options.flatten
+    );
 
     if (additionalPropertiesSpread) {
       propertiesStr.unshift(additionalPropertiesSpread);
@@ -470,8 +522,10 @@ function getAdditionalPropertiesStatement(
   const deserializerFunction = buildModelSerializer(
     context,
     additionalPropertyType,
-    false,
-    true
+    {
+      nameOnly: true,
+      skipDiscriminatedUnionSuffix: false
+    }
   );
   const params = [`item.${getAdditionalPropertiesName(context, type)} ?? {}`];
   if (typeof deserializerFunction === "string") {
@@ -497,12 +551,10 @@ function buildDictTypeSerializer(
   type: SdkDictionaryType,
   nameOnly = false
 ): FunctionDeclarationStructure | undefined | string {
-  const valueSerializer = buildModelSerializer(
-    context,
-    type.valueType,
-    false,
-    true
-  );
+  const valueSerializer = buildModelSerializer(context, type.valueType, {
+    nameOnly: true,
+    skipDiscriminatedUnionSuffix: false
+  });
   if (!valueSerializer) {
     return undefined;
   }
@@ -555,12 +607,10 @@ function buildArrayTypeSerializer(
   type: SdkArrayType,
   nameOnly = false
 ): FunctionDeclarationStructure | undefined | string {
-  const valueSerializer = buildModelSerializer(
-    context,
-    type.valueType,
-    false,
-    true
-  );
+  const valueSerializer = buildModelSerializer(context, type.valueType, {
+    nameOnly: true,
+    skipDiscriminatedUnionSuffix: false
+  });
   if (!valueSerializer) {
     return undefined;
   }

package/src/modular/serialization/serializeUtils.ts

@@ -182,4 +182,41 @@ export function isPolymorphicUnion(t: SdkType): boolean {
 export interface ModelSerializeOptions {
   nameOnly: boolean;
   skipDiscriminatedUnionSuffix: boolean;
+  // Indicates if the serializer is being built for a property that is flattened.
+  flatten?: {
+    baseModel: SdkModelType;
+    property: SdkModelPropertyType;
+  };
+  // Indicates if any overrides should be applied when building the serializer/deserializer.
+  overrides?: ModelOverrideOptions;
+  // Predefined name to use for the serializer/deserializer instead of generating one.
+  predefinedName?: string;
+}
+
+// Options for overriding model information during serialization/deserialization.
+export interface ModelOverrideOptions {
+  // If true, all properties will be treated as optional during serialization/deserialization.
+  allOptional?: boolean;
+
+  // The <Property, Client_Name> map for any renamed properties.
+  // Mainly because the original client name has collision with other property names during flattening.
+  propertyRenames?: Map<SdkModelPropertyType, string>;
+}
+
+export function getPropertyWithOverrides(
+  property: SdkModelPropertyType,
+  overrides?: ModelOverrideOptions
+): SdkModelPropertyType {
+  if (!overrides) {
+    return property;
+  }
+  let updatedProperty = property;
+  if (overrides.allOptional) {
+    updatedProperty = { ...updatedProperty, optional: true };
+  }
+  const renamedClientName = overrides.propertyRenames?.get(property);
+  if (renamedClientName) {
+    updatedProperty = { ...updatedProperty, name: renamedClientName };
+  }
+  return updatedProperty;
 }

package/src/modular/static-helpers-metadata.ts

@@ -33,6 +33,11 @@ export const SerializationHelpers = {
     kind: "function",
     name: "getBinaryResponse",
     location: "serialization/get-binary-response.ts"
+  },
+  areAllPropsUndefined: {
+    kind: "function",
+    name: "areAllPropsUndefined",
+    location: "serialization/check-prop-undefined.ts"
   }
 } as const;
 
@@ -82,6 +87,19 @@ export const PollingHelpers = {
   }
 } as const;
 
+export const SimplePollerHelpers = {
+  SimplePollerLike: {
+    kind: "interface",
+    name: "SimplePollerLike",
+    location: "simplePollerHelpers.ts"
+  },
+  getSimplePoller: {
+    kind: "function",
+    name: "getSimplePoller",
+    location: "simplePollerHelpers.ts"
+  }
+} as const;
+
 export const UrlTemplateHelpers = {
   parseTemplate: {
     kind: "function",

package/src/transform/transfromRLCOptions.ts

@@ -74,6 +74,7 @@ function extractRLCOptions(
   const productDocLink = emitterOptions["product-doc-link"];
   const isModularLibrary = emitterOptions["is-modular-library"];
   const compatibilityMode = emitterOptions["compatibility-mode"];
+  const compatibilityLro = emitterOptions["compatibility-lro"];
   const experimentalExtensibleEnums =
     emitterOptions["experimental-extensible-enums"];
   const ignorePropertyNameNormalize =
@@ -110,6 +111,7 @@ function extractRLCOptions(
     productDocLink,
     isModularLibrary,
     compatibilityMode,
+    compatibilityLro,
     experimentalExtensibleEnums,
     ignorePropertyNameNormalize,
     compatibilityQueryMultiFormat,

package/src/utils/namespaceUtils.ts

@@ -3,8 +3,10 @@ import {
   isGlobalNamespace,
   isService,
   Namespace,
+  NoTarget,
   Operation
 } from "@typespec/compiler";
+import { reportDiagnostic } from "../lib.js";
 import { SdkContext } from "./interfaces.js";
 
 export function getModelNamespaceName(
@@ -68,14 +70,28 @@ export function getOperationNamespaceInterfaceName(
 export function detectModelConflicts(dpgContext: SdkContext) {
   const allModels = getAllModels(dpgContext);
   const nameSet = new Set<string>();
+  const reported = new Set<string>();
+  let hasConflict = false;
   for (const model of allModels) {
     if (model.name === "") {
       continue;
     }
-    if (nameSet.has(model.name)) {
-      return true;
+    if (nameSet.has(model.name) && !reported.has(model.name)) {
+      reportDiagnostic(dpgContext.program, {
+        code: "detected-model-name-conflict",
+        format: {
+          modelName: model.name,
+          namespaces: allModels
+            .filter((m) => m.name === model.name)
+            .map((m) => m.namespace)
+            .join(" and ")
+        },
+        target: NoTarget
+      });
+      reported.add(model.name);
+      hasConflict = true;
     }
     nameSet.add(model.name);
   }
-  return false;
+  return hasConflict;
 }

package/src/utils/operationUtil.ts

@@ -679,6 +679,41 @@ export function getMethodHierarchiesMap(
   return operationHierarchiesMap;
 }
 
+export function isTenantLevelOperation(
+  operation: ServiceOperation,
+  client: SdkClientType<SdkServiceOperation>
+): boolean {
+  // Check if this operation has a subscriptionId path parameter
+  const subscriptionIdParam = operation.operation.parameters?.find(
+    (param) =>
+      param.name.toLowerCase() === "subscriptionid" && param.kind === "path"
+  );
+
+  if (subscriptionIdParam) {
+    // The operation has a client-level subscriptionId parameter, then it's not tenant-level
+    if (subscriptionIdParam.onClient) {
+      return false;
+    }
+  } else {
+    // Skip tenant-level internal ARM APIs
+    // Ref: https://armwiki.azurewebsites.net/rpaas/operations_auto_gen.html#special-cases
+    const pathLC = operation.operation.path.toLowerCase();
+    // Get the provider namespace from the client
+    const clientNamespaceLC = client.namespace.toLowerCase();
+    if (
+      operation.crossLanguageDefinitionId?.toLowerCase() ===
+        "azure.resourcemanager.operations.list" ||
+      pathLC.includes(`${clientNamespaceLC}/checknameavailability`)
+    ) {
+      return false;
+    }
+  }
+
+  // The operation has no subscriptionId parameter or has method-level subscriptionId parameter
+  // Considered as tenant-level
+  return true;
+}
+
 function resolveParameterNameConflict(
   operationOrGroup: SdkServiceMethod<SdkHttpOperation>,
   p: SdkMethodParameter | SdkHttpParameter | SdkBodyParameter

package/static/static-helpers/serialization/check-prop-undefined.ts

@@ -0,0 +1,17 @@
+/**
+ * Returns true if all specified properties of the item are undefined.
+ * @param item The object to check.
+ * @param properties The list of property names to check on the item.
+ * @returns True if all specified properties are undefined, otherwise false.
+ */
+export function areAllPropsUndefined(
+  item: Record<string, any>,
+  properties: string[]
+): boolean {
+  for (const property of properties) {
+    if (item[property] !== undefined) {
+      return false;
+    }
+  }
+  return true;
+}

package/static/static-helpers/simplePollerHelpers.ts

@@ -0,0 +1,125 @@
+import { PollerLike, OperationState, CancelOnProgress } from "@azure/core-lro";
+import { AbortSignalLike } from "@azure/abort-controller";
+
+/**
+ * A simple poller that can be used to poll a long running operation.
+ */
+export interface SimplePollerLike<
+  TState extends OperationState<TResult>,
+  TResult
+> {
+  /**
+   * Returns true if the poller has finished polling.
+   */
+  isDone(): boolean;
+  /**
+   * Returns the state of the operation.
+   */
+  getOperationState(): TState;
+  /**
+   * Returns the result value of the operation,
+   * regardless of the state of the poller.
+   * It can return undefined or an incomplete form of the final TResult value
+   * depending on the implementation.
+   */
+  getResult(): TResult | undefined;
+  /**
+   * Returns a promise that will resolve once a single polling request finishes.
+   * It does this by calling the update method of the Poller's operation.
+   */
+  poll(options?: { abortSignal?: AbortSignalLike }): Promise<TState>;
+  /**
+   * Returns a promise that will resolve once the underlying operation is completed.
+   */
+  pollUntilDone(pollOptions?: {
+    abortSignal?: AbortSignalLike;
+  }): Promise<TResult>;
+  /**
+   * Invokes the provided callback after each polling is completed,
+   * sending the current state of the poller's operation.
+   *
+   * It returns a method that can be used to stop receiving updates on the given callback function.
+   */
+  onProgress(callback: (state: TState) => void): CancelOnProgress;
+
+  /**
+   * Returns a promise that could be used for serialized version of the poller's operation
+   * by invoking the operation's serialize method.
+   */
+  serialize(): Promise<string>;
+
+  /**
+   * Wait the poller to be submitted.
+   */
+  submitted(): Promise<void>;
+
+  /**
+   * Returns a string representation of the poller's operation. Similar to serialize but returns a string.
+   * @deprecated Use serialize() instead.
+   */
+  toString(): string;
+
+  /**
+   * Stops the poller from continuing to poll. Please note this will only stop the client-side polling
+   * @deprecated Use abortSignal to stop polling instead.
+   */
+  stopPolling(): void;
+
+  /**
+   * Returns true if the poller is stopped.
+   * @deprecated Use abortSignal status to track this instead.
+   */
+  isStopped(): boolean;
+}
+
+/**
+ * Create the deprecated SimplePollerLike from PollerLike
+ * @param poller PollerLike to convert
+ * @returns SimplePollerLike
+ */
+export function getSimplePoller<TResult>(
+  poller: PollerLike<OperationState<TResult>, TResult>
+): SimplePollerLike<OperationState<TResult>, TResult> {
+  const simplePoller: SimplePollerLike<OperationState<TResult>, TResult> = {
+    isDone() {
+      return poller.isDone;
+    },
+    isStopped() {
+      throw new Error(
+        "isStopped is deprecated. Use abortSignal status to track this instead."
+      );
+    },
+    getOperationState() {
+      if (!poller.operationState) {
+        throw new Error(
+          "Operation state is not available. The poller may not have been started and you could await submitted() before calling getOperationState()."
+        );
+      }
+      return poller.operationState;
+    },
+    getResult() {
+      return poller.result;
+    },
+    toString() {
+      if (!poller.operationState) {
+        throw new Error(
+          "Operation state is not available. The poller may not have been started and you could await submitted() before calling getOperationState()."
+        );
+      }
+      return JSON.stringify({
+        state: poller.operationState
+      });
+    },
+    stopPolling() {
+      throw new Error(
+        "stopPolling is deprecated. Use abortSignal to stop polling instead."
+      );
+    },
+    onProgress: poller.onProgress,
+    poll: poller.poll,
+    pollUntilDone: poller.pollUntilDone,
+    serialize: poller.serialize,
+    submitted: poller.submitted
+  };
+  return simplePoller;
+}