Generate types for new MFD design

packages/rlc-common/src/buildIndexFile.ts

@@ -5,7 +5,6 @@ import { Project, SourceFile } from "ts-morph";
 import { NameType, normalizeName } from "./helpers/nameUtils.js";
 import {
   hasCsvCollection,
-  needsFilePolyfil,
   hasInputModels,
   hasMultiCollection,
   hasOutputModels,
@@ -19,7 +18,6 @@ import {
 import { RLCModel } from "./interfaces.js";
 import * as path from "path";
 import { getImportModuleName } from "./helpers/nameConstructors.js";
-import { getImportSpecifier } from "./helpers/importsUtil.js";
 
 export function buildIndexFile(model: RLCModel) {
   const multiClient = Boolean(model.options?.multiClient),
@@ -167,8 +165,6 @@ function generateRLCIndexForMultiClient(file: SourceFile, model: RLCModel) {
     exports.push("SerializeHelper");
   }
 
-  reExportFileHelperFromCore(file, model);
-
   file.addExportDeclarations([
     {
       moduleSpecifier: getImportModuleName(
@@ -331,30 +327,8 @@ function generateRLCIndex(file: SourceFile, model: RLCModel) {
     ]);
   }
 
-  reExportFileHelperFromCore(file, model);
-
   file.addExportAssignment({
     expression: createClientFuncName,
     isExportEquals: false
   });
 }
-
-// re-export file helpers from core
-function reExportFileHelperFromCore(file: SourceFile, model: RLCModel) {
-  if (needsFilePolyfil(model)) {
-    file.addExportDeclarations([
-      {
-        moduleSpecifier: getImportSpecifier(
-          "restPipeline",
-          model.importInfo.runtimeImports
-        ),
-        namedExports: [
-          "createFile",
-          "createFileFromStream",
-          "type CreateFileOptions",
-          "type CreateFileFromStreamOptions"
-        ]
-      }
-    ]);
-  }
-}

packages/rlc-common/src/buildObjectTypes.ts

@@ -3,19 +3,27 @@
 
 import {
   InterfaceDeclarationStructure,
+  OptionalKind,
   PropertySignatureStructure,
   StructureKind,
   TypeAliasDeclarationStructure
 } from "ts-morph";
 import { NameType, normalizeName } from "./helpers/nameUtils.js";
-import { isDictionarySchema, isObjectSchema } from "./helpers/schemaHelpers.js";
 import {
+  isArraySchema,
+  isDictionarySchema,
+  isObjectSchema
+} from "./helpers/schemaHelpers.js";
+import {
+  ArraySchema,
   ObjectSchema,
   Parameter,
   Property,
   RLCModel,
+  Schema,
   SchemaContext
 } from "./interfaces.js";
+import { getMultipartPartTypeName } from "./helpers/nameConstructors.js";
 
 /**
  * Generates interfaces for ObjectSchemas
@@ -40,6 +48,19 @@ export function buildObjectInterfaces(
     ) {
       continue;
     }
+
+    // FIXME: disabling new multipart generation for modular while we figure out the story
+    if (objectSchema.isMultipartBody && !model.options?.isModularLibrary) {
+      objectInterfaces.push(
+        ...buildMultipartPartDefinitions(
+          objectSchema,
+          importedModels,
+          schemaUsage
+        )
+      );
+      continue;
+    }
+
     const baseName = getObjectBaseName(objectSchema, schemaUsage);
     const interfaceDeclaration = getObjectInterfaceDeclaration(
       model,
@@ -54,6 +75,66 @@ export function buildObjectInterfaces(
   return objectInterfaces;
 }
 
+const MULTIPART_FILE_METADATA_PROPERTIES: OptionalKind<PropertySignatureStructure>[] =
+  [
+    {
+      name: "filename",
+      hasQuestionToken: true,
+      type: "string"
+    },
+    {
+      name: "contentType",
+      hasQuestionToken: true,
+      type: "string"
+    }
+  ];
+
+function buildMultipartPartDefinitions(
+  schema: ObjectSchema,
+  importedModels: Set<string>,
+  schemaUsage: SchemaContext[]
+): InterfaceDeclarationStructure[] {
+  if (!schema.isMultipartBody) {
+    return [];
+  }
+
+  // Transform property signatures into individual models
+  const propertySignatures = getPropertySignatures(
+    schema.properties ?? {},
+    schemaUsage,
+    importedModels,
+    { flattenBinaryArrays: true }
+  );
+
+  const structures: InterfaceDeclarationStructure[] = [];
+
+  for (const signature of propertySignatures) {
+    const name = signature.name;
+    const typeName = getMultipartPartTypeName(schema.name, name);
+
+    const isFileUpload = signature.type?.toString().includes("File") ?? false;
+
+    structures.push({
+      kind: StructureKind.Interface,
+      isExported: true,
+      name: typeName,
+      properties: [
+        {
+          name: "name",
+          type: name
+        },
+        {
+          name: "body",
+          type: signature.type
+        },
+        ...(isFileUpload ? MULTIPART_FILE_METADATA_PROPERTIES : [])
+      ]
+    });
+  }
+
+  return structures;
+}
+
 export function buildObjectAliases(
   model: RLCModel,
   importedModels: Set<string>,
@@ -67,6 +148,30 @@ export function buildObjectAliases(
   const objectAliases: TypeAliasDeclarationStructure[] = [];
 
   for (const objectSchema of objectSchemas) {
+    // FIXME: disabling new multipart generation for modular while we figure out the story
+    if (objectSchema.isMultipartBody && !model.options?.isModularLibrary) {
+      const propertySignatures = getPropertySignatures(
+        objectSchema.properties ?? {},
+        schemaUsage,
+        importedModels,
+        { flattenBinaryArrays: true }
+      );
+
+      const objectTypeNames = propertySignatures.map((sig) =>
+        getMultipartPartTypeName(objectSchema.name, sig.name)
+      );
+
+      objectAliases.push({
+        kind: StructureKind.TypeAlias,
+        ...(objectSchema.description && {
+          docs: [{ description: objectSchema.description }]
+        }),
+        name: objectSchema.typeName!,
+        type: `FormData | Array<${objectTypeNames.join("|") || "unknown"}>`,
+        isExported: true
+      });
+    }
+
     if (objectSchema.alias || objectSchema.outputAlias) {
       const description = objectSchema.description;
       const modelName = schemaUsage.includes(SchemaContext.Input)
@@ -424,10 +529,15 @@ export function getImmediateParentsNames(
   return [...parents, ...extendFrom];
 }
 
+interface GetPropertySignatureOptions {
+  flattenBinaryArrays?: boolean;
+}
+
 function getPropertySignatures(
   properties: { [key: string]: Property },
   schemaUsage: SchemaContext[],
-  importedModels: Set<string>
+  importedModels: Set<string>,
+  options: GetPropertySignatureOptions = {}
 ) {
   let validProperties = Object.keys(properties);
   const readOnlyFilter = (name: string) =>
@@ -438,63 +548,82 @@ function getPropertySignatures(
     getPropertySignature(
       { ...properties[p], name: p },
       schemaUsage,
-      importedModels
+      importedModels,
+      options
     )
   );
 }
 
+function isBinaryArray(schema: Schema): boolean {
+  return Boolean(
+    isArraySchema(schema) &&
+      (schema.items?.typeName?.includes("NodeJS.ReadableStream") ||
+        schema.items?.outputTypeName?.includes("NodeJS.ReadableStream"))
+  );
+}
+
 /**
  * Builds a Typescript property or parameter signature
- * @param property - Property or parameter to get the Typescript signature for
+ * @param schema - Property or parameter to get the Typescript signature for
  * @param importedModels - Set to track the models that need to be imported
  * @returns a PropertySignatureStructure for the property.
  */
 export function getPropertySignature(
   property: Property | Parameter,
   schemaUsage: SchemaContext[],
-  importedModels: Set<string>
+  importedModels: Set<string>,
+  options: GetPropertySignatureOptions = {}
 ): PropertySignatureStructure {
-  const propertyName = property.name;
-  const description = property.description;
+  let schema: Schema;
+  if (options.flattenBinaryArrays && isBinaryArray(property)) {
+    schema = {
+      ...((property as ArraySchema).items ?? property),
+      name: property.name
+    };
+  } else {
+    schema = property;
+  }
+
+  const propertyName = schema.name;
+  const description = schema.description;
   let type;
   const hasCoreInArray =
-    property.type === "array" &&
-    (property as any).items &&
-    (property as any).items.fromCore;
+    schema.type === "array" &&
+    (schema as any).items &&
+    (schema as any).items.fromCore;
   const hasCoreInRecord =
-    property.type === "dictionary" &&
-    (property as any).additionalProperties &&
-    (property as any).additionalProperties.fromCore;
-  if (hasCoreInArray && property.typeName) {
-    type = property.typeName;
+    schema.type === "dictionary" &&
+    (schema as any).additionalProperties &&
+    (schema as any).additionalProperties.fromCore;
+  if (hasCoreInArray && schema.typeName) {
+    type = schema.typeName;
     importedModels.add(
-      (property as any).items.typeName ?? (property as any).items.name
+      (schema as any).items.typeName ?? (schema as any).items.name
     );
-  } else if (hasCoreInRecord && property.typeName) {
-    type = property.typeName;
+  } else if (hasCoreInRecord && schema.typeName) {
+    type = schema.typeName;
     importedModels.add(
-      (property as any).additionalProperties.typeName ??
-        (property as any).additionalProperties.name
+      (schema as any).additionalProperties.typeName ??
+        (schema as any).additionalProperties.name
     );
   } else {
     type =
-      generateForOutput(schemaUsage, property.usage) && property.outputTypeName
-        ? property.outputTypeName
-        : property.typeName
-          ? property.typeName
-          : property.type;
-    if (property.typeName && property.fromCore) {
-      importedModels.add(property.typeName);
-      type = property.typeName;
+      generateForOutput(schemaUsage, schema.usage) && schema.outputTypeName
+        ? schema.outputTypeName
+        : schema.typeName
+          ? schema.typeName
+          : schema.type;
+    if (schema.typeName && schema.fromCore) {
+      importedModels.add(schema.typeName);
+      type = schema.typeName;
     }
   }
 
   return {
     name: propertyName,
     ...(description && { docs: [{ description }] }),
-    hasQuestionToken: !property.required,
-    isReadonly:
-      generateForOutput(schemaUsage, property.usage) && property.readOnly,
+    hasQuestionToken: !schema.required,
+    isReadonly: generateForOutput(schemaUsage, schema.usage) && schema.readOnly,
     type,
     kind: StructureKind.PropertySignature
   };

packages/rlc-common/src/helpers/importsUtil.ts

@@ -12,7 +12,7 @@ export function buildRuntimeImports(flavor?: PackageFlavor): Imports {
       restClient: {
         type: "restClient",
         specifier: "@azure-rest/core-client",
-        version: "^1.4.0"
+        version: "^2.0.0"
       },
       coreAuth: {
         type: "coreAuth",

packages/rlc-common/src/helpers/nameConstructors.ts

@@ -134,3 +134,13 @@ export function getClientName(model: RLCModel) {
 
   return clientInterfaceName;
 }
+
+export function getMultipartPartTypeName(schemaName: string, partName: string) {
+  const name = normalizeName(partName, NameType.Interface);
+  const bodyParamName = normalizeName(schemaName, NameType.Interface);
+
+  return normalizeName(
+    `${bodyParamName}_${name}_PartDescriptor`,
+    NameType.Interface
+  );
+}