@azure-tools/typespec-ts 0.55.0-dev.1 → 0.55.0-dev.3

package/src/modular/helpers/type-helpers.ts

@@ -0,0 +1,134 @@
+import {
+  SdkBodyParameter,
+  SdkCredentialParameter,
+  SdkEndpointParameter,
+  SdkMethodParameter,
+  SdkModelType,
+  SdkType,
+} from "@azure-tools/typespec-client-generator-core";
+import { NameType, normalizeName } from "../../rlc-common/index.js";
+import { SdkContext } from "../../utils/interfaces.js";
+import {
+  getPropertyWithOverrides,
+  ModelOverrideOptions,
+} from "../serialization/serialize-utils.js";
+import { getAllAncestors, getAllProperties } from "./operation-helpers.js";
+
+export function getDirectSubtypes(type: SdkModelType) {
+  if (!type.discriminatedSubtypes) {
+    return [];
+  }
+  // Filter out subtypes that extend from other discriminated subtypes (hierarchical inheritance)
+  return Object.values(type.discriminatedSubtypes).filter((subtype) => subtype.baseModel === type);
+}
+
+export function getAdditionalPropertiesType(type: SdkType | undefined): SdkType | undefined {
+  if (
+    !type ||
+    !(
+      "additionalProperties" in type ||
+      (type.kind === "model" && getAdditionalPropertiesType(type.baseModel))
+    )
+  ) {
+    return undefined;
+  }
+
+  if (type.additionalProperties) {
+    return type.additionalProperties;
+  }
+
+  if (type.baseModel) {
+    return getAdditionalPropertiesType(type.baseModel);
+  }
+
+  return undefined;
+}
+
+export function isTypeNullable(type: SdkType) {
+  return Boolean(type.kind === "nullable");
+}
+
+export function getNullableValidType(type: SdkType): SdkType {
+  if (type.kind === "nullable") {
+    return type.type;
+  }
+  return type;
+}
+
+const NumericTypeKinds = [
+  "numeric",
+  "integer",
+  "safeint",
+  "int8",
+  "int16",
+  "int32",
+  "int64",
+  "uint8",
+  "uint16",
+  "uint32",
+  "uint64",
+  "float",
+  "float32",
+  "float64",
+  "decimal",
+  "decimal128",
+];
+
+const DateTimeTypeKinds = ["plainTime"];
+
+// This may be a good candidate to move to TCGC
+export function isNumericTypeKind(kind: string): boolean {
+  return NumericTypeKinds.includes(kind);
+}
+
+export function isDateTimeTypeKind(kind: string): boolean {
+  return DateTimeTypeKinds.includes(kind);
+}
+
+export function isCredentialType(
+  type: SdkEndpointParameter | SdkCredentialParameter | SdkMethodParameter,
+): boolean {
+  return type.kind === "credential";
+}
+
+/**
+ * Builds a property name mapper between the serializedName and the name of the property.
+ * Return empty map if the type is not a model.
+ */
+export function buildPropertyNameMapper(
+  context: SdkContext,
+  model: SdkType,
+  overrides?: ModelOverrideOptions,
+) {
+  const mapper = new Map<string, string>();
+  if (model.kind !== "model") {
+    return mapper;
+  }
+  const allProperties = getAllProperties(context, model, getAllAncestors(model));
+  for (const p of allProperties) {
+    if (p.kind !== "property") {
+      continue;
+    }
+    const prop = getPropertyWithOverrides(p, overrides);
+    mapper.set(
+      prop.serializationOptions.json?.name || prop.name,
+      normalizeName(prop.name, NameType.Property),
+    );
+  }
+  return mapper;
+}
+
+/**
+ * Checks if the body parameter is a spread parameter.
+ * @param body
+ * @returns
+ */
+export function isSpreadBodyParameter(body: SdkBodyParameter) {
+  const methodParams = body.methodParameterSegments;
+  return (
+    methodParams.length > 1 ||
+    (methodParams.length === 1 &&
+      methodParams[0]?.length === 1 &&
+      methodParams[0][0]?.type !== body.type)
+  );
+}

package/src/modular/serialization/build-deserializer-function.ts

@@ -0,0 +1,564 @@
+import {
+  SdkArrayType,
+  SdkDictionaryType,
+  SdkModelPropertyType,
+  SdkModelType,
+  SdkType,
+  SdkUnionType,
+  UsageFlags,
+} from "@azure-tools/typespec-client-generator-core";
+import { NoTarget } from "@typespec/compiler";
+import { FunctionDeclarationStructure, StructureKind } from "ts-morph";
+import { useContext } from "../../context-manager.js";
+import { resolveReference } from "../../framework/reference.js";
+import { refkey } from "../../framework/refkey.js";
+import { reportDiagnostic } from "../../lib.js";
+import { NameType, normalizeName } from "../../rlc-common/index.js";
+import { SdkContext } from "../../utils/interfaces.js";
+import { isAzureCoreErrorType } from "../../utils/model-utils.js";
+import { getAdditionalPropertiesName, normalizeModelName } from "../emit-models.js";
+import {
+  getAllAncestors,
+  getAllProperties,
+  getPropertySerializedName,
+  getResponseMapping,
+} from "../helpers/operation-helpers.js";
+import { getAdditionalPropertiesType, getDirectSubtypes } from "../helpers/type-helpers.js";
+import { SerializationHelpers } from "../static-helpers-metadata.js";
+import {
+  getAllDiscriminatedValues,
+  isDiscriminatedUnion,
+  isSupportedSerializeType,
+  ModelSerializeOptions,
+} from "./serialize-utils.js";
+
+export function buildPropertyDeserializer(
+  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,
+  )}Deserializer`;
+  return buildModelDeserializer(context, property.type, {
+    ...options,
+    flatten: {
+      baseModel: propertyContext.baseModel,
+      property,
+    },
+    overrides: {
+      allOptional: property.optional,
+      propertyRenames: propertyContext.conflictMap,
+    },
+    predefinedName,
+  });
+}
+
+export function buildModelDeserializer(
+  context: SdkContext,
+  type: SdkType,
+  options: ModelSerializeOptions = {
+    nameOnly: false,
+    skipDiscriminatedUnionSuffix: false,
+  },
+): FunctionDeclarationStructure | undefined | string {
+  // const modelTcgcType = getTcgcType(type) as SdkModelType;
+  if (!isSupportedSerializeType(type)) {
+    return undefined;
+  }
+  const { nameOnly, skipDiscriminatedUnionSuffix } = options;
+  if (type.kind === "model" || type.kind === "union" || type.kind === "enum") {
+    if (
+      !type.usage ||
+      (type.usage !== undefined &&
+        (type.usage & UsageFlags.Output) !== UsageFlags.Output &&
+        (type.usage & UsageFlags.Exception) !== UsageFlags.Exception)
+    ) {
+      return undefined;
+    }
+    if (!type.name) {
+      // TODO: https://github.com/Azure/typespec-azure/issues/1713 and https://github.com/microsoft/typespec/issues/4815
+      // throw new Error(`NYI Serialization of anonymous types`);
+      return undefined;
+    }
+    if (isAzureCoreErrorType(context.program, type.__raw!)) {
+      return undefined;
+    }
+  }
+
+  if (!isDiscriminatedUnion(type) && type.kind === "model" && type.discriminatorProperty) {
+    return buildPolymorphicDeserializer(context, type, nameOnly);
+  }
+
+  if (isDiscriminatedUnion(type) && !skipDiscriminatedUnionSuffix) {
+    return buildDiscriminatedUnionDeserializer(context, type, nameOnly);
+  }
+
+  switch (type.kind) {
+    case "model":
+      return buildModelTypeDeserializer(context, type, options);
+    case "union": // for non-discriminated union, we just return whatever we get
+      return buildUnionDeserializer(context, type, nameOnly);
+    case "dict":
+      return buildDictTypeDeserializer(context, type, nameOnly);
+    case "array":
+      return buildArrayTypeDeserializer(context, type, nameOnly);
+    default:
+      return undefined;
+  }
+}
+
+function buildPolymorphicDeserializer(
+  context: SdkContext,
+  type: SdkModelType,
+  nameOnly: boolean,
+): string;
+function buildPolymorphicDeserializer(
+  context: SdkContext,
+  type: SdkModelType,
+): FunctionDeclarationStructure | undefined;
+function buildPolymorphicDeserializer(
+  context: SdkContext,
+  type: SdkModelType,
+  nameOnly = false,
+): FunctionDeclarationStructure | undefined | string {
+  if (!type.name) {
+    reportDiagnostic(context.program, {
+      code: "anonymous-type-deserialization",
+      target: type.__raw || NoTarget,
+    });
+    return undefined; // Return undefined to skip this deserialization
+  }
+  const deserializeFunctionName = `${normalizeModelName(
+    context,
+    type,
+    NameType.Operation,
+  )}Deserializer`;
+  if (nameOnly) {
+    return resolveReference(refkey(type, "deserializer"));
+  }
+  const deserializerFunction: FunctionDeclarationStructure = {
+    kind: StructureKind.Function,
+    name: deserializeFunctionName,
+    isExported: true,
+    parameters: [
+      {
+        name: "item",
+        type: "any",
+      },
+    ],
+    returnType: resolveReference(refkey(type, "polymorphicType")),
+    statements: [],
+  };
+  if (!type.discriminatorProperty) {
+    return;
+  }
+  const statements: string[] = [];
+
+  const subTypes = type.discriminatedSubtypes;
+  if (!subTypes) {
+    // No subtypes - treat as a regular model and generate simple deserializer
+    return buildModelTypeDeserializer(context, type, {
+      nameOnly,
+      skipDiscriminatedUnionSuffix: false,
+    });
+  }
+
+  const cases: string[] = [];
+  Object.keys(subTypes).forEach((discriminatedValue) => {
+    const subType = subTypes[discriminatedValue];
+    if (
+      !subType?.usage ||
+      (subType?.usage !== undefined && (subType.usage & UsageFlags.Output) !== UsageFlags.Output)
+    ) {
+      return;
+    }
+    const union = subType?.discriminatedSubtypes ? "_Union" : "";
+    if (!subType || !subType?.name) {
+      reportDiagnostic(context.program, {
+        code: "anonymous-type-deserialization",
+        target: subType?.__raw || NoTarget,
+      });
+      return; // Skip this subtype
+    }
+
+    const rawSubTypeName = `${subType.name}${union}`;
+    const subTypeName = `${normalizeName(rawSubTypeName, NameType.Interface, true)}`;
+    const subtypeDeserializerName = normalizeName(
+      `${subTypeName}Deserializer`,
+      NameType.Operation,
+      true,
+    );
+
+    cases.push(`
+        case "${discriminatedValue}":
+          return ${subtypeDeserializerName}(item as ${subTypeName});
+      `);
+  });
+
+  // Use wire format name for the switch since item is raw JSON from the service
+  const discriminatorWireName = getPropertySerializedName(type.discriminatorProperty);
+  statements.push(`
+      switch (item["${discriminatorWireName}"]) {
+       ${cases.join("\n")}
+        default:
+          return item;
+      }
+    `);
+  deserializerFunction.statements = statements.join("\n");
+  return deserializerFunction;
+}
+
+function buildDiscriminatedUnionDeserializer(
+  context: SdkContext,
+  type: SdkModelType,
+  nameOnly: boolean,
+): string;
+function buildDiscriminatedUnionDeserializer(
+  context: SdkContext,
+  type: SdkModelType,
+): FunctionDeclarationStructure | undefined;
+function buildDiscriminatedUnionDeserializer(
+  context: SdkContext,
+  type: SdkModelType,
+  nameOnly = false,
+): FunctionDeclarationStructure | undefined | string {
+  if (!type.name) {
+    reportDiagnostic(context.program, {
+      code: "anonymous-type-deserialization",
+      target: type.__raw || NoTarget,
+    });
+    return undefined; // Return undefined to skip this deserialization
+  }
+  const cases: string[] = [];
+  const output: string[] = [];
+  const deserializeFunctionName = `${normalizeModelName(
+    context,
+    type,
+    NameType.Operation,
+  )}Deserializer`;
+  if (nameOnly) {
+    return resolveReference(refkey(type, "deserializer"));
+  }
+  // Get the base deserializer name and ensure reference tracking
+  const baseDeserializerName = `${normalizeModelName(
+    context,
+    type,
+    NameType.Operation,
+    true,
+  )}Deserializer`;
+  const directSubtypes = getDirectSubtypes(type);
+  for (const subType of directSubtypes) {
+    if (
+      !subType.usage ||
+      (subType.usage !== undefined && (subType.usage & UsageFlags.Output) !== UsageFlags.Output)
+    ) {
+      continue;
+    }
+    // get all discriminated values that is linked by this discriminator property
+    const discriminatedValues = getAllDiscriminatedValues(subType, type.discriminatorProperty);
+    const union = subType.discriminatedSubtypes ? "Union" : "";
+    const subTypeName = normalizeModelName(context, subType, NameType.Interface, !union);
+    // Get the deserializer name and ensure reference tracking
+    const subtypeDeserializerName = buildModelDeserializer(context, subType, {
+      nameOnly: true,
+      skipDiscriminatedUnionSuffix: false,
+    }) as string;
+
+    const caseLabels = discriminatedValues.map((value) => `case "${value}":`);
+    cases.push(`
+      ${caseLabels.join("\n")}
+        return ${subtypeDeserializerName}(item as ${subTypeName});
+    `);
+  }
+  // Use wire format name for the switch since item is raw JSON from the service
+  const discriminatorWireName = type.discriminatorProperty
+    ? getPropertySerializedName(type.discriminatorProperty)
+    : "unknown";
+  output.push(`
+    switch (item["${discriminatorWireName}"]) {
+     ${cases.join("\n")}
+      default:
+        return ${baseDeserializerName}(item);
+    }
+  `);
+
+  const deserializerFunction: FunctionDeclarationStructure = {
+    kind: StructureKind.Function,
+    name: deserializeFunctionName,
+    isExported: true,
+    parameters: [
+      {
+        name: "item",
+        type: "any",
+      },
+    ],
+    returnType: resolveReference(refkey(type, "polymorphicType")),
+    statements: output.join("\n"),
+  };
+  return deserializerFunction;
+}
+
+function buildUnionDeserializer(context: SdkContext, type: SdkUnionType, nameOnly: boolean): string;
+function buildUnionDeserializer(
+  context: SdkContext,
+  type: SdkUnionType,
+): FunctionDeclarationStructure;
+function buildUnionDeserializer(
+  context: SdkContext,
+  type: SdkUnionType,
+  nameOnly = false,
+): FunctionDeclarationStructure | string | undefined {
+  if (!type.name) {
+    reportDiagnostic(context.program, {
+      code: "anonymous-type-deserialization",
+      target: type.__raw || NoTarget,
+    });
+    return ""; // Return empty string to continue processing
+  }
+  const deserializerFunctionName = `${normalizeModelName(
+    context,
+    type,
+    NameType.Operation,
+  )}Deserializer`;
+  if (nameOnly) {
+    return resolveReference(refkey(type, "deserializer"));
+  }
+  const deserializerFunction: FunctionDeclarationStructure = {
+    kind: StructureKind.Function,
+    name: deserializerFunctionName,
+    isExported: true,
+    parameters: [
+      {
+        name: "item",
+        type: "any",
+      },
+    ],
+    returnType: resolveReference(refkey(type)),
+    statements: ["return item;"],
+  };
+  return deserializerFunction;
+}
+
+function buildModelTypeDeserializer(
+  context: SdkContext,
+  type: SdkModelType,
+  options: ModelSerializeOptions = {
+    nameOnly: false,
+    skipDiscriminatedUnionSuffix: false,
+  },
+): FunctionDeclarationStructure | string | undefined {
+  if (!type.name) {
+    reportDiagnostic(context.program, {
+      code: "anonymous-type-deserialization",
+      target: type.__raw || NoTarget,
+    });
+    return ""; // Return empty string to continue processing
+  }
+  const deserializerFunctionName =
+    options.predefinedName ??
+    `${normalizeModelName(
+      context,
+      type,
+      NameType.Operation,
+      options.skipDiscriminatedUnionSuffix,
+    )}Deserializer`;
+  if (options.nameOnly) {
+    return options.flatten
+      ? resolveReference(refkey(options.flatten.property, "deserializer"))
+      : resolveReference(refkey(type, "deserializer"));
+  }
+  const deserializerFunction: FunctionDeclarationStructure = {
+    kind: StructureKind.Function,
+    name: deserializerFunctionName,
+    isExported: true,
+    parameters: [
+      {
+        name: "item",
+        type: "any",
+      },
+    ],
+    returnType: options.flatten
+      ? undefined // not set return type for flattened property deserializer and type system will infer correct one
+      : resolveReference(refkey(type)),
+    statements: ["return item;"],
+  };
+  const nullabilityPrefix = "";
+
+  const additionalPropertiesSpread = getAdditionalPropertiesStatement(context, type) ?? "";
+
+  const propertiesStr = getResponseMapping(
+    context,
+    type,
+    "item",
+    options.overrides,
+    !options.flatten,
+  );
+  const propertiesDeserialization = propertiesStr.filter((p) => p.trim());
+
+  const output = [];
+
+  // don't emit a serializer if there is nothing to serialize
+  if (propertiesDeserialization.length || additionalPropertiesSpread) {
+    const fnBody = `{
+           ${additionalPropertiesSpread}
+           ${nullabilityPrefix} ${propertiesDeserialization.join(",\n")}
+        }`;
+    output.push(`
+        return ${fnBody}
+      `);
+  } else {
+    output.push(`
+        return item;
+      `);
+  }
+  deserializerFunction.statements = output;
+  return deserializerFunction;
+}
+
+function getAdditionalPropertiesStatement(
+  context: SdkContext,
+  type: SdkModelType,
+): string | undefined {
+  const additionalPropertyType = getAdditionalPropertiesType(type);
+  if (!additionalPropertyType) {
+    return undefined;
+  }
+  const allParents = getAllAncestors(type);
+  const properties = getAllProperties(context, type, allParents);
+  const excludeProperties = properties.filter((p) => !!p.name).map((p) => `"${p.name}"`);
+  const params = ["item"];
+  params.push(`[${excludeProperties.join(",")}]`);
+  const deserializerFunction = buildModelDeserializer(context, additionalPropertyType, {
+    nameOnly: true,
+    skipDiscriminatedUnionSuffix: false,
+  });
+  if (typeof deserializerFunction === "string") {
+    params.push(deserializerFunction);
+  }
+  return context.rlcOptions?.compatibilityMode === true
+    ? "...item,"
+    : `${getAdditionalPropertiesName(context, type)}: ${resolveReference(SerializationHelpers.serializeRecord)}(${params.join(",")}),`;
+}
+
+function buildDictTypeDeserializer(
+  context: SdkContext,
+  type: SdkDictionaryType,
+  nameOnly: boolean,
+): string;
+function buildDictTypeDeserializer(
+  context: SdkContext,
+  type: SdkDictionaryType,
+): FunctionDeclarationStructure | undefined;
+function buildDictTypeDeserializer(
+  context: SdkContext,
+  type: SdkDictionaryType,
+  nameOnly = false,
+): FunctionDeclarationStructure | undefined | string {
+  const valueDeserializer = buildModelDeserializer(context, type.valueType, {
+    nameOnly: true,
+    skipDiscriminatedUnionSuffix: false,
+  });
+  if (!valueDeserializer) {
+    return undefined;
+  }
+  if (!isSupportedSerializeType(type.valueType)) {
+    return undefined;
+  }
+
+  if (typeof valueDeserializer !== "string") {
+    return undefined;
+  }
+
+  const deserializerFunctionName = `${normalizeModelName(context, type, NameType.Operation, false, true)}Deserializer`;
+  if (nameOnly) {
+    return resolveReference(refkey(type, "deserializer"));
+  }
+  const deserializerFunction: FunctionDeclarationStructure = {
+    kind: StructureKind.Function,
+    name: deserializerFunctionName,
+    isExported: true,
+    parameters: [
+      {
+        name: "item",
+        type: "Record<string, any>",
+      },
+    ],
+    returnType: `Record<string, ${resolveReference(refkey(type.valueType)) ?? "any"}>`,
+    statements: [
+      `
+  const result: Record<string, any> = {};
+  Object.keys(item).map((key) => {
+    result[key] = !item[key]? item[key]: ${valueDeserializer}(item[key])
+  });
+  return result;
+      `,
+    ],
+  };
+  return deserializerFunction;
+}
+
+function buildArrayTypeDeserializer(
+  context: SdkContext,
+  type: SdkArrayType,
+  nameOnly: boolean,
+): string;
+function buildArrayTypeDeserializer(
+  context: SdkContext,
+  type: SdkArrayType,
+): FunctionDeclarationStructure | undefined;
+function buildArrayTypeDeserializer(
+  context: SdkContext,
+  type: SdkArrayType,
+  nameOnly = false,
+): FunctionDeclarationStructure | undefined | string {
+  const valueDeserializer = buildModelDeserializer(context, type.valueType, {
+    nameOnly: true,
+    skipDiscriminatedUnionSuffix: false,
+  });
+  if (!valueDeserializer) {
+    return undefined;
+  }
+  if (!isSupportedSerializeType(type.valueType)) {
+    return undefined;
+  }
+
+  if (typeof valueDeserializer !== "string") {
+    return undefined;
+  }
+  const deserializerFunctionName = `${normalizeModelName(context, type, NameType.Operation, false, true)}Deserializer`;
+  if (nameOnly) {
+    return resolveReference(refkey(type, "deserializer"));
+  }
+  const serializerFunction: FunctionDeclarationStructure = {
+    kind: StructureKind.Function,
+    name: deserializerFunctionName,
+    isExported: true,
+    parameters: [
+      {
+        name: "result",
+        type: `Array<${normalizeModelName(context, type.valueType as any) ?? "any"}>`,
+      },
+    ],
+    returnType: "any[]",
+    statements: [
+      `
+  return result.map((item) => {
+    return ${valueDeserializer}(item)
+  });
+      `,
+    ],
+  };
+  return serializerFunction;
+}