@azure-tools/typespec-ts 0.29.0-alpha.20240626.1 → 0.30.0

package/src/modular/serialization/buildSerializerFunction.ts

@@ -0,0 +1,224 @@
+import { toCamelCase, toPascalCase } from "../../utils/casingUtils.js";
+import { Type as ModularType } from "../modularCodeModel.js";
+import { getRequestModelMapping } from "../helpers/operationHelpers.js";
+import { useContext } from "../../contextManager.js";
+
+import {
+  Imports as RuntimeImports,
+  SchemaContext,
+  addImportToSpecifier
+} from "@azure-tools/rlc-common";
+import { UsageFlags } from "@typespec/compiler";
+import {
+  SdkModelType,
+  SdkType
+} from "@azure-tools/typespec-client-generator-core";
+
+function getTcgcType(type: ModularType): SdkType {
+  if (type.tcgcType?.kind === "nullable") {
+    return type.tcgcType.type!;
+  }
+  return type.tcgcType!;
+}
+export function buildModelSerializer(
+  type: ModularType,
+  runtimeImports: RuntimeImports
+): string | undefined {
+  const rlcMetadata = useContext("rlcMetaTree");
+  const modelTcgcType = getTcgcType(type) as SdkModelType;
+  if (
+    modelTcgcType.usage !== undefined &&
+    (modelTcgcType.usage & UsageFlags.Input) !== UsageFlags.Input
+  ) {
+    return undefined;
+  }
+
+  if (!type.name) {
+    throw new Error(`NYI Serialization of anonymous types`);
+  }
+
+  let serializerName = `${toCamelCase(type.name)}Serializer`;
+
+  const restModel = rlcMetadata.get(type.__raw!);
+  const restModelName = restModel?.rlcType.name;
+
+  const output: string[] = [];
+
+  if (
+    !isDiscriminatedUnion(type) &&
+    type.type === "combined" &&
+    type.discriminator
+  ) {
+    return buildPolymorphicSerializer(type);
+  }
+
+  if (isDiscriminatedUnion(type)) {
+    const discriminatedTgcType = getTcgcType(type) as SdkModelType;
+    const cases: string[] = [];
+    const baseSerializerName = `${toCamelCase(
+      discriminatedTgcType.name
+    )}Serializer`;
+    for (const key in discriminatedTgcType.discriminatedSubtypes) {
+      const subType = discriminatedTgcType.discriminatedSubtypes[key]!;
+      const discriminatedValue = subType.discriminatorValue!;
+      const union = subType.discriminatedSubtypes ? "Union" : "";
+      const subTypeName = `${toPascalCase(subType.name)}${union}`;
+      const subtypeSerializerName = toCamelCase(`${subTypeName}Serializer`);
+
+      cases.push(`
+        case "${discriminatedValue}":
+          return ${subtypeSerializerName}(item as ${subTypeName});
+      `);
+    }
+    output.push(`
+    export function ${toCamelCase(type.name)}Serializer(item: ${toPascalCase(
+      type.name
+    )}) {
+      switch (item.${type.discriminator}) {
+       ${cases.join("\n")}
+        default:
+          return ${baseSerializerName}(item);
+      }
+    }
+    `);
+
+    serializerName = baseSerializerName;
+  }
+
+  let serializerReturnType = "";
+
+  // There are some situations where the type is not present in the REST API,
+  // this can happen when client.tsp overrides visibility to public on an orphan model
+  // In this case we just let TypeScript infer the return type.
+  let restModelNameAlias = "";
+  if (restModelName && restModel.rlcType.usage?.includes(SchemaContext.Input)) {
+    restModelNameAlias = `${restModelName}Rest`;
+    serializerReturnType = `: ${restModelNameAlias}`;
+  }
+
+  if (type.type === "model" || type.type === "dict") {
+    const nullabilityPrefix = "";
+    // getPropertySerializationPrefix({
+    //   clientName: "item",
+    //   type
+    // });
+
+    // This is only handling the compatibility mode, will need to update when we handle additionalProperties property.
+    const additionalPropertiesSpread = hasAdditionalProperties(type.tcgcType)
+      ? "...item,"
+      : "";
+
+    const { propertiesStr, directAssignment } = getRequestModelMapping(
+      type,
+      "item",
+      runtimeImports
+    );
+    const propertiesSerialization = propertiesStr.filter((p) => p.trim());
+
+    // don't emit a serializer if there is nothing to serialize
+    if (propertiesSerialization.length || additionalPropertiesSpread) {
+      const spreadSerialized = directAssignment ? "..." : "";
+      const fnBody = `{
+             ${additionalPropertiesSpread}
+             ${nullabilityPrefix} ${spreadSerialized} ${propertiesSerialization.join(
+               ",\n"
+             )}
+          }`;
+      output.push(`
+        export function ${serializerName}(item: ${toPascalCase(
+          type.name
+        )})${serializerReturnType} {
+          return ${fnBody}
+        }
+        `);
+
+      if (serializerReturnType) {
+        addImportToSpecifier(
+          "rlcIndex",
+          runtimeImports,
+          `${restModelName} as ${restModelNameAlias}`
+        );
+      }
+    } else {
+      output.push(`
+        export function ${serializerName}(item: ${toPascalCase(type.name)}) {
+          return item as any;
+        }
+        `);
+    }
+  } else if (type.type === "enum") {
+    output.push(`
+    export function ${serializerName}(item: ${toPascalCase(
+      type.name
+    )})${serializerReturnType} {
+      return item;
+    }
+    `);
+  }
+
+  return output.join("\n");
+}
+
+function isDiscriminatedUnion(
+  type: ModularType
+): type is ModularType & { tcgcType: SdkModelType } {
+  const { tcgcType } = type;
+
+  return Boolean(
+    tcgcType?.kind === "model" &&
+      tcgcType.discriminatorProperty &&
+      tcgcType.discriminatedSubtypes
+  );
+}
+
+function hasAdditionalProperties(type: SdkType | undefined) {
+  if (!type || !("additionalProperties" in type)) {
+    return false;
+  }
+
+  if (type.additionalProperties) {
+    return true;
+  }
+
+  if (type.baseModel) {
+    return hasAdditionalProperties(type.baseModel);
+  }
+
+  return false;
+}
+
+function buildPolymorphicSerializer(type: ModularType) {
+  if (!type.discriminator) {
+    return;
+  }
+  const output: string[] = [];
+
+  const subTypes = type.types ?? [];
+
+  const cases: string[] = [];
+  for (const subType of subTypes) {
+    const discriminatedValue = subType.discriminatorValue!;
+    const union = subType.types ? "Union" : "";
+    const subTypeName = `${toPascalCase(subType.name!)}${union}`;
+    const subtypeSerializerName = toCamelCase(`${subTypeName}Serializer`);
+
+    cases.push(`
+        case "${discriminatedValue}":
+          return ${subtypeSerializerName}(item as ${subTypeName});
+      `);
+  }
+
+  output.push(`
+    export function ${toCamelCase(type.name!)}Serializer(item: ${toPascalCase(
+      type.name!
+    )}) {
+      switch (item.${type.discriminator}) {
+       ${cases.join("\n")}
+        default:
+          return item;
+      }
+    }
+    `);
+
+  return output.join("\n");
+}

package/src/transform/transformSchemas.ts

@@ -19,6 +19,7 @@ import {
   isAzureCoreErrorType,
   trimUsage
 } from "../utils/modelUtils.js";
+import { useContext } from "../contextManager.js";
 
 export function transformSchemas(client: SdkClient, dpgContext: SdkContext) {
   const program = dpgContext.program;
@@ -118,6 +119,7 @@ export function transformSchemas(client: SdkClient, dpgContext: SdkContext) {
   }
   transformHostParameters();
   usageMap.forEach((context, tspModel) => {
+    const metatree = useContext("rlcMetaTree");
     const model = getSchemaForType(dpgContext, tspModel, {
       usage: context,
       isRequestBody: requestBodySet.has(tspModel),
@@ -127,6 +129,7 @@ export function transformSchemas(client: SdkClient, dpgContext: SdkContext) {
     if (model) {
       model.usage = context;
     }
+    metatree.set(tspModel, { rlcType: model });
     if (model.name === "") {
       return;
     }

package/src/utils/importHelper.ts

@@ -0,0 +1,64 @@
+import { dirname, relative, resolve } from "path";
+import { useContext } from "../contextManager.js";
+import { SourceFile } from "ts-morph";
+
+/**
+ * Adds a named import to a TypeScript source file if it does not already exist.
+ * Utilizes a global symbol map context to resolve module paths and ensure the import is correctly referenced.
+ *
+ * @param {string} symbol The name of the export to import.
+ * @param {SourceFile} currentFile The ts-morph SourceFile object where the import will be added.
+ */
+export function addImportBySymbol(symbol: string, currentFile: SourceFile) {
+  // Retrieve the global map of symbols to their source files.
+  const symbolMap = useContext("symbolMap");
+
+  // Attempt to resolve the file path for the given symbol.
+  const modulePath = symbolMap.get(symbol)?.getFilePath();
+  if (!modulePath) {
+    return;
+  }
+
+  // Resolve absolute path and compute a relative path from the current file to the module.
+  const moduleAbsolutePath = resolve(modulePath);
+  const relativeImportPath = getRelativeImportPath(
+    currentFile.getFilePath(),
+    moduleAbsolutePath
+  )
+    .replace(/\\/g, "/")
+    .replace(/\.ts$/, ".js");
+
+  // Check if the import declaration already exists and if it includes the symbol.
+  const existing = currentFile.getImportDeclaration(
+    (i) => i.getModuleSpecifierValue() === relativeImportPath
+  );
+
+  if (existing) {
+    const sameImport = existing
+      .getNamedImports()
+      .some((i) => i.getName() === symbol);
+
+    if (!sameImport) {
+      existing.addNamedImport(symbol);
+    }
+  } else {
+    currentFile.addImportDeclaration({
+      moduleSpecifier: relativeImportPath,
+      namedImports: [symbol]
+    });
+  }
+}
+
+/**
+ * Computes a relative import path suitable for TypeScript imports given two file paths.
+ * Ensures the returned path starts with './' if necessary to be recognized as a relative module.
+ *
+ * @param {string} from The file path to import from.
+ * @param {string} to The file path to import to.
+ * @returns {string} The relative path adjusted for import syntax.
+ */
+function getRelativeImportPath(from: string, to: string) {
+  const relativePath = relative(dirname(from), to);
+  // Adjust the path format to TypeScript module syntax
+  return relativePath.startsWith(".") ? relativePath : "./" + relativePath;
+}