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

package/src/modular/helpers/typeHelpers.ts

@@ -1,131 +0,0 @@
-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/serializeUtils.js";
-import { getAllAncestors, getAllProperties } from "./operationHelpers.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/buildDeserializerFunction.ts

@@ -1,564 +0,0 @@
-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 "../../contextManager.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/modelUtils.js";
-import { getAdditionalPropertiesName, normalizeModelName } from "../emitModels.js";
-import {
-  getAllAncestors,
-  getAllProperties,
-  getPropertySerializedName,
-  getResponseMapping,
-} from "../helpers/operationHelpers.js";
-import { getAdditionalPropertiesType, getDirectSubtypes } from "../helpers/typeHelpers.js";
-import { SerializationHelpers } from "../static-helpers-metadata.js";
-import {
-  getAllDiscriminatedValues,
-  isDiscriminatedUnion,
-  isSupportedSerializeType,
-  ModelSerializeOptions,
-} from "./serializeUtils.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;
-}