@azure-tools/typespec-ts 0.54.0 → 0.54.2

package/src/modular/serialization/serialize-utils.ts

@@ -0,0 +1,217 @@
+import {
+  SdkModelPropertyType,
+  SdkModelType,
+  SdkType,
+} from "@azure-tools/typespec-client-generator-core";
+import { getAllAncestors } from "../helpers/operation-helpers.js";
+import { getDirectSubtypes } from "../helpers/type-helpers.js";
+
+/**
+ * Get all discriminated values for a given model type and given discriminator property.
+ * @param type The model type to get discriminated values from.
+ * @param discriminatorProperty The discriminator property to use for filtering.
+ * @returns An array of all discriminated values.
+ */
+export function getAllDiscriminatedValues(
+  type: SdkModelType,
+  discriminatorProperty?: SdkModelPropertyType,
+) {
+  if (!type.discriminatorValue) {
+    return [];
+  }
+  const values: string[] = [];
+  const children = [type];
+  while (children.length > 0) {
+    const model = children.shift()!;
+    // skip if no discriminator value
+    if (!model.discriminatorValue) {
+      continue;
+    }
+    // Check if this model is a subtype of the given discriminator property
+    if (
+      !!discriminatorProperty &&
+      model.baseModel?.discriminatorProperty?.name === discriminatorProperty?.name
+    ) {
+      values.push(model.discriminatorValue);
+      if (model.discriminatorProperty?.name === discriminatorProperty.name) {
+        // Traverse subtypes also if they have the same discriminator property
+        children.push(...getDirectSubtypes(model));
+      }
+    }
+  }
+
+  return values;
+}
+
+export function isSupportedSerializeType(type: SdkType): boolean {
+  return (
+    type.kind === "model" || type.kind === "dict" || type.kind === "array" || type.kind === "union"
+  );
+}
+
+/**
+ *
+ * In general, we have two kinds of basic special union variants.
+ * 1. datetime type
+ * 2. bytes type
+ * If we consider model type, we have the following three type.
+ * 3. model with property of datetime type.
+ * 4. model with property of binary array type.
+ * 5. model that has different property name between rest layer and modular layer.
+ * 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<SdkType, boolean>();
+export function isSpecialUnionVariant(
+  t: SdkType & { isNonExhaustive?: boolean },
+  variantStack: SdkType[] = [],
+): boolean {
+  if (variantStack.length <= 0) {
+    variantStack.push(t);
+  }
+  const ancestors = getAllAncestors(t);
+  if (specialVariantMap.has(t)) {
+    variantStack.pop();
+    return specialVariantMap.get(t) ?? false;
+  }
+
+  if (
+    t.kind === "utcDateTime" ||
+    t.kind === "plainDate" ||
+    t.kind === "bytes" ||
+    (t.kind === "model" &&
+      t.properties
+        ?.filter((p) => {
+          return !(
+            variantStack.includes(p.type) ||
+            ancestors.includes(p.type) ||
+            (p.type.kind === "array" &&
+              p.type.valueType &&
+              (variantStack.includes(p.type.valueType) || ancestors.includes(p.type.valueType)))
+          );
+        })
+        ?.some(
+          (p) =>
+            (p.kind === "property" && p.name !== p.serializationOptions.json?.name) ||
+            isSpecialUnionVariant(p.type, [...variantStack, p.type]),
+        )) ||
+    isPolymorphicUnion(t) ||
+    (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.kind === "enum" && !(t.isFixed || t.isNonExhaustive))
+  ) {
+    specialVariantMap.set(t, true);
+    variantStack.pop();
+    return true;
+  }
+  variantStack.pop();
+  specialVariantMap.set(t, false);
+  return false;
+}
+
+export function isNormalUnion(t: SdkType): boolean {
+  return (
+    t.kind === "union" &&
+    !(
+      t.variantTypes?.some((p) => {
+        return isSpecialUnionVariant(p);
+      }) ?? false
+    )
+  );
+}
+
+export function isDiscriminatedUnion(
+  type: SdkType,
+): type is SdkModelType & { discriminatorProperty: SdkType } {
+  if (!type) {
+    return false;
+  }
+  return Boolean(
+    type?.kind === "model" && type.discriminatorProperty && type.discriminatedSubtypes,
+  );
+}
+
+export function isSpecialHandledUnion(t: SdkType & { isNonExhaustive?: boolean }): boolean {
+  return isDiscriminatedUnion(t!) || isPolymorphicUnion(t);
+}
+
+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.kind === "model" &&
+    t.discriminatedSubtypes &&
+    Object.values(t.discriminatedSubtypes)
+      ?.filter((p) => {
+        return !ancestors.includes(p);
+      })
+      ?.some((p) => {
+        return isSpecialUnionVariant(p);
+      })
+  ) {
+    polymorphicUnionMap.set(t, true);
+    return true;
+  }
+  polymorphicUnionMap.set(t, false);
+  return false;
+}
+
+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>;
+
+  // If true (default), enable flattening for nested flatten properties when generating samples.
+  // When false, nested flatten properties are not further flattened to match the TypeScript interface structure.
+  enableFlatten?: boolean;
+}
+
+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/rollup.test.config.js

@@ -1,16 +1,13 @@
+import { makeBrowserTestConfig, makeConfig } from "@azure/dev-tool/shared-config/rollup";
 import cjs from "@rollup/plugin-commonjs";
 import inject from "@rollup/plugin-inject";
 import json from "@rollup/plugin-json";
 import multiEntry from "@rollup/plugin-multi-entry";
 import nodeResolve from "@rollup/plugin-node-resolve";
 import replace from "@rollup/plugin-replace";
+import typescript from "@rollup/plugin-typescript";
 import shim from "rollup-plugin-shim";
 import sourcemaps from "rollup-plugin-sourcemaps";
-import typescript from "@rollup/plugin-typescript";
-import {
-  makeConfig,
-  makeBrowserTestConfig
-} from "@azure/dev-tool/shared-config/rollup";
 
 const inputs = makeConfig(require("./package.json"));
 
@@ -26,7 +23,7 @@ function makeBrowserTestConfigPatch() {
   config.plugins = [
     multiEntry({ exports: false }),
     typescript({
-      exclude: ["test/**/*.spec.ts"]
+      exclude: ["test/**/*.spec.ts"],
     }),
     sourcemaps(),
     replace({
@@ -36,29 +33,29 @@ function makeBrowserTestConfigPatch() {
       // browser only. Rollup's dead code elimination will remove
       // any code guarded by if (isNode) { ... }
       "if (isNode)": "if (false)",
-      "if (!isNode)": "if (true)"
+      "if (!isNode)": "if (true)",
     }),
     // fs, net, and tls are used by rhea and need to be shimmed
     // dotenv doesn't work in the browser, so replace it with a no-op function
     shim({
-      dotenv: `export function config() { }`
+      dotenv: `export function config() { }`,
     }),
     nodeResolve({
       mainFields: ["module", "browser"],
-      preferBuiltins: false
+      preferBuiltins: false,
     }),
     cjs({
       namedExports: {
-        chai: ["should", "assert"]
-      }
+        chai: ["should", "assert"],
+      },
     }),
     inject({
       modules: {
-        process: "process"
+        process: "process",
       },
-      exclude: ["./**/package.json"]
+      exclude: ["./**/package.json"],
     }),
-    json()
+    json(),
   ];
 
   return config;

package/src/modular/static/scripts/renameOutput.mjs

@@ -5,7 +5,7 @@ import * as fs from "fs";
 import * as path from "path";
 import * as url from "url";
 
-const __dirname = url.fileURLToPath(new URL('.', import.meta.url));
+const __dirname = url.fileURLToPath(new URL(".", import.meta.url));
 const destinationPath = path.join(__dirname, "../dist/");
 
 const inputFile = path.join(destinationPath, "index.js");
@@ -14,4 +14,4 @@ const inputMapFile = path.join(destinationPath, "index.js.map");
 if (fs.existsSync(inputFile) && fs.existsSync(inputMapFile)) {
   fs.renameSync(inputFile, path.join(destinationPath, "index.cjs"));
   fs.renameSync(inputMapFile, path.join(destinationPath, "index.cjs.map"));
-}
+}

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

@@ -2,275 +2,275 @@ export const SerializationHelpers = {
   buildMultiCollection: {
     kind: "function",
     name: "buildMultiCollection",
-    location: "serialization/build-multi-collection.ts"
+    location: "serialization/build-multi-collection.ts",
   },
   buildCsvCollection: {
     kind: "function",
     name: "buildCsvCollection",
-    location: "serialization/build-csv-collection.ts"
+    location: "serialization/build-csv-collection.ts",
   },
   buildPipeCollection: {
     kind: "function",
     name: "buildPipeCollection",
-    location: "serialization/build-pipe-collection.ts"
+    location: "serialization/build-pipe-collection.ts",
   },
   buildSsvCollection: {
     kind: "function",
     name: "buildSsvCollection",
-    location: "serialization/build-ssv-collection.ts"
+    location: "serialization/build-ssv-collection.ts",
   },
   buildTsvCollection: {
     kind: "function",
     name: "buildTsvCollection",
-    location: "serialization/build-tsv-collection.ts"
+    location: "serialization/build-tsv-collection.ts",
   },
   buildNewlineCollection: {
     kind: "function",
     name: "buildNewlineCollection",
-    location: "serialization/build-newline-collection.ts"
+    location: "serialization/build-newline-collection.ts",
   },
   parseCsvCollection: {
     kind: "function",
     name: "parseCsvCollection",
-    location: "serialization/parse-csv-collection.ts"
+    location: "serialization/parse-csv-collection.ts",
   },
   parsePipeCollection: {
     kind: "function",
     name: "parsePipeCollection",
-    location: "serialization/parse-pipe-collection.ts"
+    location: "serialization/parse-pipe-collection.ts",
   },
   parseSsvCollection: {
     kind: "function",
     name: "parseSsvCollection",
-    location: "serialization/parse-ssv-collection.ts"
+    location: "serialization/parse-ssv-collection.ts",
   },
   parseNewlineCollection: {
     kind: "function",
     name: "parseNewlineCollection",
-    location: "serialization/parse-newline-collection.ts"
+    location: "serialization/parse-newline-collection.ts",
   },
   serializeRecord: {
     kind: "function",
     name: "serializeRecord",
-    location: "serialization/serialize-record.ts"
+    location: "serialization/serialize-record.ts",
   },
   getBinaryResponse: {
     kind: "function",
     name: "getBinaryResponse",
-    location: "serialization/get-binary-response.ts"
+    location: "serialization/get-binary-response.ts",
   },
   getBinaryStreamResponse: {
     kind: "function",
     name: "getBinaryStreamResponse",
-    location: "serialization/get-binary-stream-response.ts"
+    location: "serialization/get-binary-stream-response.ts",
   },
   areAllPropsUndefined: {
     kind: "function",
     name: "areAllPropsUndefined",
-    location: "serialization/check-prop-undefined.ts"
-  }
+    location: "serialization/check-prop-undefined.ts",
+  },
 } as const;
 
 export const PagingHelpers = {
   PageSettings: {
     kind: "interface",
     name: "PageSettings",
-    location: "pagingHelpers.ts"
+    location: "pagingHelpers.ts",
   },
   ContinuablePage: {
     kind: "typeAlias",
     name: "ContinuablePage",
-    location: "pagingHelpers.ts"
+    location: "pagingHelpers.ts",
   },
   PagedAsyncIterableIterator: {
     kind: "interface",
     name: "PagedAsyncIterableIterator",
-    location: "pagingHelpers.ts"
+    location: "pagingHelpers.ts",
   },
   PagedResult: {
     kind: "interface",
     name: "PagedResult",
-    location: "pagingHelpers.ts"
+    location: "pagingHelpers.ts",
   },
   BuildPagedAsyncIteratorOptions: {
     kind: "interface",
     name: "BuildPagedAsyncIteratorOptions",
-    location: "pagingHelpers.ts"
+    location: "pagingHelpers.ts",
   },
   BuildPagedAsyncIterator: {
     kind: "function",
     name: "buildPagedAsyncIterator",
-    location: "pagingHelpers.ts"
-  }
+    location: "pagingHelpers.ts",
+  },
 } as const;
 
 export const PollingHelpers = {
   GetLongRunningPollerOptions: {
     kind: "interface",
     name: "GetLongRunningPollerOptions",
-    location: "pollingHelpers.ts"
+    location: "pollingHelpers.ts",
   },
   GetLongRunningPoller: {
     kind: "function",
     name: "getLongRunningPoller",
-    location: "pollingHelpers.ts"
-  }
+    location: "pollingHelpers.ts",
+  },
 } as const;
 
 export const SimplePollerHelpers = {
   SimplePollerLike: {
     kind: "interface",
     name: "SimplePollerLike",
-    location: "simplePollerHelpers.ts"
+    location: "simplePollerHelpers.ts",
   },
   getSimplePoller: {
     kind: "function",
     name: "getSimplePoller",
-    location: "simplePollerHelpers.ts"
-  }
+    location: "simplePollerHelpers.ts",
+  },
 } as const;
 
 export const UrlTemplateHelpers = {
   parseTemplate: {
     kind: "function",
     name: "expandUrlTemplate",
-    location: "urlTemplate.ts"
-  }
+    location: "urlTemplate.ts",
+  },
 } as const;
 export const MultipartHelpers = {
   FileContents: {
     kind: "typeAlias",
     name: "FileContents",
-    location: "multipartHelpers.ts"
+    location: "multipartHelpers.ts",
   },
   createFilePartDescriptor: {
     kind: "function",
     name: "createFilePartDescriptor",
-    location: "multipartHelpers.ts"
-  }
+    location: "multipartHelpers.ts",
+  },
 } as const;
 
 export const PlatformTypeHelpers = {
   NodeReadableStream: {
     kind: "typeAlias",
     name: "NodeReadableStream",
-    location: "platform-types.ts"
-  }
+    location: "platform-types.ts",
+  },
 } as const;
 
 export const CloudSettingHelpers = {
   AzureClouds: {
     kind: "enum",
     name: "AzureClouds",
-    location: "cloudSettingHelpers.ts"
+    location: "cloudSettingHelpers.ts",
   },
   AzureSupportedClouds: {
     kind: "typeAlias",
     name: "AzureSupportedClouds",
-    location: "cloudSettingHelpers.ts"
+    location: "cloudSettingHelpers.ts",
   },
   getArmEndpoint: {
     kind: "function",
     name: "getArmEndpoint",
-    location: "cloudSettingHelpers.ts"
-  }
+    location: "cloudSettingHelpers.ts",
+  },
 } as const;
 
 export const CreateRecorderHelpers = {
   createRecorder: {
     kind: "function",
     name: "createRecorder",
-    location: "recordedClient.ts"
-  }
+    location: "recordedClient.ts",
+  },
 } as const;
 
 export const XmlHelpers = {
   XmlSerializationOptions: {
     kind: "interface",
     name: "XmlSerializationOptions",
-    location: "serialization/xml-helpers.ts"
+    location: "serialization/xml-helpers.ts",
   },
   XmlPropertyMetadata: {
     kind: "interface",
     name: "XmlPropertyMetadata",
-    location: "serialization/xml-helpers.ts"
+    location: "serialization/xml-helpers.ts",
   },
   XmlPropertyDeserializeMetadata: {
     kind: "interface",
     name: "XmlPropertyDeserializeMetadata",
-    location: "serialization/xml-helpers.ts"
+    location: "serialization/xml-helpers.ts",
   },
   XmlAdditionalPropertiesConfig: {
     kind: "interface",
     name: "XmlAdditionalPropertiesConfig",
-    location: "serialization/xml-helpers.ts"
+    location: "serialization/xml-helpers.ts",
   },
   serializeModelToXml: {
     kind: "function",
     name: "serializeModelToXml",
-    location: "serialization/xml-helpers.ts"
+    location: "serialization/xml-helpers.ts",
   },
   serializeToXml: {
     kind: "function",
     name: "serializeToXml",
-    location: "serialization/xml-helpers.ts"
+    location: "serialization/xml-helpers.ts",
   },
   xmlObjectToString: {
     kind: "function",
     name: "xmlObjectToString",
-    location: "serialization/xml-helpers.ts"
+    location: "serialization/xml-helpers.ts",
   },
   parseXmlString: {
     kind: "function",
     name: "parseXmlString",
-    location: "serialization/xml-helpers.ts"
+    location: "serialization/xml-helpers.ts",
   },
   deserializeXmlToModel: {
     kind: "function",
     name: "deserializeXmlToModel",
-    location: "serialization/xml-helpers.ts"
+    location: "serialization/xml-helpers.ts",
   },
   deserializeFromXml: {
     kind: "function",
     name: "deserializeFromXml",
-    location: "serialization/xml-helpers.ts"
+    location: "serialization/xml-helpers.ts",
   },
   deserializeXmlObject: {
     kind: "function",
     name: "deserializeXmlObject",
-    location: "serialization/xml-helpers.ts"
+    location: "serialization/xml-helpers.ts",
   },
   isXmlContentType: {
     kind: "function",
     name: "isXmlContentType",
-    location: "serialization/xml-helpers.ts"
+    location: "serialization/xml-helpers.ts",
   },
   isJsonContentType: {
     kind: "function",
     name: "isJsonContentType",
-    location: "serialization/xml-helpers.ts"
+    location: "serialization/xml-helpers.ts",
   },
   XmlSerializedObject: {
     kind: "interface",
     name: "XmlSerializedObject",
-    location: "serialization/xml-helpers.ts"
-  }
+    location: "serialization/xml-helpers.ts",
+  },
 } as const;
 
 export const StorageCompatHelpers = {
   StorageCompatResponseInfo: {
     kind: "interface",
     name: "StorageCompatResponseInfo",
-    location: "storageCompatResponse.ts"
+    location: "storageCompatResponse.ts",
   },
   createStorageCompatOnResponse: {
     kind: "function",
     name: "createStorageCompatOnResponse",
-    location: "storageCompatResponse.ts"
+    location: "storageCompatResponse.ts",
   },
   addStorageCompatResponse: {
     kind: "function",
     name: "addStorageCompatResponse",
-    location: "storageCompatResponse.ts"
-  }
+    location: "storageCompatResponse.ts",
+  },
 } as const;

package/src/modular/type-expressions/get-credential-expression.ts

@@ -1,6 +1,6 @@
 import { SdkCredentialType } from "@azure-tools/typespec-client-generator-core";
+import { useDependencies } from "../../framework/hooks/use-dependencies.js";
 import { resolveReference } from "../../framework/reference.js";
-import { useDependencies } from "../../framework/hooks/useDependencies.js";
 
 export function getCredentialExpression(type: SdkCredentialType): string {
   const dependencies = useDependencies();

package/src/modular/type-expressions/get-enum-expression.ts

@@ -1,13 +1,13 @@
 import { SdkEnumType } from "@azure-tools/typespec-client-generator-core";
 import { resolveReference } from "../../framework/reference.js";
-import { getTypeExpression, EmitTypeOptions } from "./get-type-expression.js";
-import { shouldEmitInline } from "./utils.js";
 import { SdkContext } from "../../utils/interfaces.js";
+import { EmitTypeOptions, getTypeExpression } from "./get-type-expression.js";
+import { shouldEmitInline } from "./utils.js";
 
 export function getEnumExpression(
   context: SdkContext,
   type: SdkEnumType,
-  options: EmitTypeOptions = {}
+  options: EmitTypeOptions = {},
 ): string {
   if (shouldEmitInline(type, options)) {
     return !isExtensibleEnum(context, type)
@@ -18,11 +18,6 @@ export function getEnumExpression(
   }
 }
 
-export function isExtensibleEnum(
-  context: SdkContext,
-  type: SdkEnumType
-): boolean {
-  return (
-    !type.isFixed && context.rlcOptions?.experimentalExtensibleEnums === true
-  );
+export function isExtensibleEnum(context: SdkContext, type: SdkEnumType): boolean {
+  return !type.isFixed && context.rlcOptions?.experimentalExtensibleEnums === true;
 }