@azure-tools/typespec-ts 0.37.0 → 0.38.0

package/src/modular/buildRootIndex.ts

@@ -1,12 +1,9 @@
 import { NameType, normalizeName } from "@azure-tools/rlc-common";
 import { Project, SourceFile } from "ts-morph";
-import {
-  getClassicalClientName,
-  getClientName
-} from "./helpers/namingHelpers.js";
+import { getClassicalClientName } from "./helpers/namingHelpers.js";
 import { ModularEmitterOptions } from "./interfaces.js";
 import { resolveReference } from "../framework/reference.js";
-import { PagingHelpers } from "./static-helpers-metadata.js";
+import { MultipartHelpers, PagingHelpers } from "./static-helpers-metadata.js";
 import {
   SdkClientType,
   SdkContext,
@@ -14,6 +11,7 @@ import {
 } from "@azure-tools/typespec-client-generator-core";
 import { getModularClientOptions } from "../utils/clientUtils.js";
 import { getMethodHierarchiesMap } from "../utils/operationUtil.js";
+import { join } from "path/posix";
 
 export function buildRootIndex(
   context: SdkContext,
@@ -53,11 +51,12 @@ export function buildRootIndex(
   const modelsExportsIndex = rootIndexFile
     .getExportDeclarations()
     ?.find((i) => {
-      return i.getModuleSpecifierValue() === `./models/index.js`;
+      return i.getModuleSpecifierValue()?.startsWith(`./models/`);
     });
   if (!modelsExportsIndex) {
     exportModules(rootIndexFile, project, srcPath, clientName, "models", {
-      isTopLevel: true
+      isTopLevel: true,
+      recursive: true
     });
   }
   exportModules(rootIndexFile, project, srcPath, clientName, "api", {
@@ -71,6 +70,7 @@ export function buildRootIndex(
   });
 
   exportPagingTypes(context, rootIndexFile);
+  exportFileContentsType(context, rootIndexFile);
 }
 
 /**
@@ -109,6 +109,28 @@ function hasPaging(context: SdkContext): boolean {
   });
 }
 
+function exportFileContentsType(
+  context: SdkContext,
+  rootIndexFile: SourceFile
+) {
+  if (
+    context.sdkPackage.models.some((x) =>
+      x.properties.some(
+        (y) => y.kind === "property" && y.multipartOptions?.isFilePart
+      )
+    )
+  ) {
+    const existingExports = getExistingExports(rootIndexFile);
+    const namedExports = [resolveReference(MultipartHelpers.FileContents)];
+
+    const newNamedExports = getNewNamedExports(namedExports, existingExports);
+
+    if (newNamedExports.length > 0) {
+      addExportsToRootIndexFile(rootIndexFile, newNamedExports);
+    }
+  }
+}
+
 function getExistingExports(rootIndexFile: SourceFile): Set<string> {
   return new Set(
     rootIndexFile
@@ -177,7 +199,7 @@ function exportClassicalClient(
   subfolder: string,
   isSubClient: boolean = false
 ) {
-  const clientName = `${getClientName(client)}Client`;
+  const clientName = client.name;
   indexFile.addExportDeclaration({
     namedExports: [clientName],
     moduleSpecifier: `./${
@@ -190,6 +212,7 @@ export interface ExportModulesOptions {
   interfaceOnly?: boolean;
   isTopLevel?: boolean;
   subfolder?: string;
+  recursive?: boolean;
 }
 
 function exportModules(
@@ -201,58 +224,80 @@ function exportModules(
   options: ExportModulesOptions = {
     interfaceOnly: false,
     isTopLevel: false,
-    subfolder: ""
+    subfolder: "",
+    recursive: false
   }
 ) {
-  const modelsFile = project.getSourceFile(
-    `${srcPath}/${
-      options.subfolder !== "" && options.subfolder
-        ? options.subfolder + "/"
-        : ""
-    }${moduleName}/index.ts`
-  );
-  if (!modelsFile) {
-    return;
+  const subfolder = options.subfolder ?? "";
+  let folders = [];
+  if (options.recursive) {
+    folders = project
+      .getDirectories()
+      .filter((dir) => {
+        const targetPath = join(srcPath, subfolder, moduleName);
+        return dir.getPath().replace(/\\/g, "/").startsWith(targetPath);
+      })
+      .map((dir) => {
+        return dir.getPath();
+      });
+  } else {
+    folders = [join(srcPath, subfolder, moduleName)];
   }
+  for (const folder of folders) {
+    const apiFilePattern = join(folder, "index.ts");
+    const modelsFile = project.getSourceFile(apiFilePattern);
+    if (!modelsFile) {
+      continue;
+    }
 
-  const exported = [...indexFile.getExportedDeclarations().keys()];
-  const namedExports = [...modelsFile.getExportedDeclarations().entries()]
-    .filter((exDeclaration) => {
-      if (exDeclaration[0].startsWith("_")) {
-        return false;
-      }
-      return exDeclaration[1].some((ex) => {
-        if (
-          options.interfaceOnly &&
-          ex.getKindName() !== "InterfaceDeclaration"
-        ) {
+    const exported = [...indexFile.getExportedDeclarations().keys()];
+
+    const namedExports = [...modelsFile.getExportedDeclarations().entries()]
+      .filter((exDeclaration) => {
+        if (exDeclaration[0].startsWith("_")) {
           return false;
         }
-        if (
-          options.interfaceOnly &&
-          options.isTopLevel &&
-          exDeclaration[0].endsWith("Context")
-        ) {
-          return false;
+        return exDeclaration[1].some((ex) => {
+          if (
+            options.interfaceOnly &&
+            ex.getKindName() !== "InterfaceDeclaration"
+          ) {
+            return false;
+          }
+          if (
+            moduleName === "models" &&
+            ex.getKindName() === "FunctionDeclaration" &&
+            (exDeclaration[0].endsWith("Serializer") ||
+              exDeclaration[0].endsWith("Deserializer"))
+          ) {
+            return false;
+          }
+          if (
+            options.interfaceOnly &&
+            options.isTopLevel &&
+            exDeclaration[0].endsWith("Context")
+          ) {
+            return false;
+          }
+          return true;
+        });
+      })
+      .map((exDeclaration) => {
+        if (exported.indexOf(exDeclaration[0]) > -1) {
+          return `${exDeclaration[0]} as ${clientName}${exDeclaration[0]}`;
         }
-        return true;
+        return exDeclaration[0];
       });
-    })
-    .map((exDeclaration) => {
-      if (exported.indexOf(exDeclaration[0]) > -1) {
-        return `${exDeclaration[0]} as ${clientName}${exDeclaration[0]}`;
-      }
-      return exDeclaration[0];
+    const moduleSpecifier = `.${modelsFile
+      .getFilePath()
+      .replace(indexFile.getDirectoryPath(), "")
+      .replace(/\\/g, "/")
+      .replace(".ts", "")}.js`;
+    indexFile.addExportDeclaration({
+      moduleSpecifier,
+      namedExports
     });
-  const moduleSpecifier = `./${
-    options.isTopLevel && options.subfolder !== "" && options.subfolder
-      ? options.subfolder + "/"
-      : ""
-  }${moduleName}/index.js`;
-  indexFile.addExportDeclaration({
-    moduleSpecifier,
-    namedExports
-  });
+  }
 }
 
 export function buildSubClientIndexFile(
@@ -267,7 +312,7 @@ export function buildSubClientIndexFile(
     undefined,
     { overwrite: true }
   );
-  const clientName = `${getClientName(client)}Client`;
+  const clientName = `${getClassicalClientName(client)}`;
   const clientFilePath = `${srcPath}/${
     subfolder && subfolder !== "" ? subfolder + "/" : ""
   }${normalizeName(clientName, NameType.File)}.ts`;

package/src/modular/buildSubpathIndex.ts

@@ -11,6 +11,7 @@ import { getModularClientOptions } from "../utils/clientUtils.js";
 export interface buildSubpathIndexFileOptions {
   exportIndex?: boolean;
   interfaceOnly?: boolean;
+  recursive?: boolean;
 }
 
 export function buildSubpathIndexFile(
@@ -26,73 +27,94 @@ export function buildSubpathIndexFile(
   const srcPath = emitterOptions.modularOptions.sourceRoot;
   // Skip to export these files because they are used internally.
   const skipFiles = ["pagingHelpers.ts", "pollingHelpers.ts"];
-  const apiFilePattern = join(srcPath, subfolder, subpath);
-  const apiFiles = emitterOptions.project.getSourceFiles().filter((file) => {
-    return file
-      .getFilePath()
-      .replace(/\\/g, "/")
-      .startsWith(apiFilePattern.replace(/\\/g, "/"));
-  });
-  if (apiFiles.length === 0) {
-    return;
+  let folders = [];
+  if (options.recursive) {
+    folders = emitterOptions.project
+      .getDirectories()
+      .filter((dir) => {
+        const targetPath = join(srcPath, subfolder, subpath);
+        return (
+          dir.getPath().replace(/\\/g, "/").startsWith(targetPath) &&
+          !emitterOptions.project.getSourceFile(`${dir}/index.ts`)
+        );
+      })
+      .map((dir) => {
+        return dir.getPath();
+      });
+  } else {
+    folders = [join(srcPath, subfolder, subpath)];
   }
-  const indexFile = emitterOptions.project.createSourceFile(
-    `${srcPath}/${subfolder}/${subpath}/index.ts`
-  );
-  for (const file of apiFiles) {
-    const filePath = file.getFilePath();
-    if (!options.exportIndex && filePath.endsWith("index.ts")) {
-      continue;
-    }
-    // Skip to export these files because they are used internally.
-    if (skipFiles.some((skipFile) => filePath.endsWith(skipFile))) {
-      continue;
-    }
-    if (filePath === indexFile.getFilePath()) {
+  for (const folder of folders) {
+    const apiFilePattern =
+      subpath === "models" ? join(folder, "models.ts") : folder;
+    const apiFiles = emitterOptions.project.getSourceFiles().filter((file) => {
+      return file
+        .getFilePath()
+        .replace(/\\/g, "/")
+        .startsWith(apiFilePattern.replace(/\\/g, "/"));
+    });
+    if (apiFiles.length === 0) {
       continue;
     }
+    const indexFile = emitterOptions.project.createSourceFile(
+      `${folder}/index.ts`
+    );
+    for (const file of apiFiles) {
+      const filePath = file.getFilePath();
+      if (!options.exportIndex && filePath.endsWith("index.ts")) {
+        continue;
+      }
+      // Skip to export these files because they are used internally.
+      if (skipFiles.some((skipFile) => filePath.endsWith(skipFile))) {
+        continue;
+      }
+      if (filePath === indexFile.getFilePath()) {
+        continue;
+      }
 
-    let namedExports: string[] = [...file.getExportedDeclarations().entries()]
-      .filter((exDeclaration) => {
-        if (exDeclaration[0].startsWith("_")) {
-          return false;
-        }
-        return exDeclaration[1].some((ex) => {
-          if (
-            options.interfaceOnly &&
-            ex.getKindName() !== "InterfaceDeclaration"
-          ) {
+      let namedExports: string[] = [...file.getExportedDeclarations().entries()]
+        .filter((exDeclaration) => {
+          if (exDeclaration[0].startsWith("_")) {
             return false;
           }
+          return exDeclaration[1].some((ex) => {
+            if (
+              options.interfaceOnly &&
+              ex.getKindName() !== "InterfaceDeclaration"
+            ) {
+              return false;
+            }
 
-          // skip exporting serializers for models
-          if (
-            subpath === "models" &&
-            ex.getKindName() === "FunctionDeclaration" &&
-            (exDeclaration[0].endsWith("Serializer") ||
-              exDeclaration[0].endsWith("Deserializer"))
-          ) {
-            return false;
-          }
+            // skip exporting serializers for models
+            if (
+              subpath === "models" &&
+              ex.getKindName() === "FunctionDeclaration" &&
+              (exDeclaration[0].endsWith("Serializer") ||
+                exDeclaration[0].endsWith("Deserializer"))
+            ) {
+              return false;
+            }
 
-          return true;
+            return true;
+          });
+        })
+        .map((exDeclaration) => {
+          return exDeclaration[0];
         });
-      })
-      .map((exDeclaration) => {
-        return exDeclaration[0];
+      // Skip to export PagedResult and BuildPagedAsyncIteratorOptions
+      if (filePath.endsWith("pagingTypes.ts")) {
+        namedExports = namedExports.filter(
+          (ex) =>
+            !["PagedResult", "BuildPagedAsyncIteratorOptions"].includes(ex)
+        );
+      }
+      indexFile.addExportDeclaration({
+        moduleSpecifier: `.${filePath
+          .replace(indexFile.getDirectoryPath(), "")
+          .replace(/\\/g, "/")
+          .replace(".ts", "")}.js`,
+        namedExports
       });
-    // Skip to export PagedResult and BuildPagedAsyncIteratorOptions
-    if (filePath.endsWith("pagingTypes.ts")) {
-      namedExports = namedExports.filter(
-        (ex) => !["PagedResult", "BuildPagedAsyncIteratorOptions"].includes(ex)
-      );
     }
-    indexFile.addExportDeclaration({
-      moduleSpecifier: `.${filePath
-        .replace(indexFile.getDirectoryPath(), "")
-        .replace(/\\/g, "/")
-        .replace(".ts", "")}.js`,
-      namedExports
-    });
   }
 }

package/src/modular/emitModels.ts

@@ -35,7 +35,6 @@ import {
 
 import { SdkContext } from "../utils/interfaces.js";
 import { addDeclaration } from "../framework/declaration.js";
-import { addImportBySymbol } from "../utils/importHelper.js";
 import { buildModelDeserializer } from "./serialization/buildDeserializerFunction.js";
 import { buildModelSerializer } from "./serialization/buildSerializerFunction.js";
 import { extractPagedMetadataNested } from "../utils/operationUtil.js";
@@ -46,7 +45,7 @@ import {
 import path from "path";
 import { refkey } from "../framework/refkey.js";
 import { useContext } from "../contextManager.js";
-import { isMetadata } from "@typespec/http";
+import { isMetadata, isOrExtendsHttpFile } from "@typespec/http";
 import {
   isAzureCoreErrorType,
   isAzureCoreLroType
@@ -56,6 +55,8 @@ import { isDiscriminatedUnion } from "./serialization/serializeUtils.js";
 import { reportDiagnostic } from "../lib.js";
 import { NoTarget } from "@typespec/compiler";
 import { emitQueue } from "../framework/hooks/sdkTypes.js";
+import { resolveReference } from "../framework/reference.js";
+import { MultipartHelpers } from "./static-helpers-metadata.js";
 
 type InterfaceStructure = OptionalKind<InterfaceDeclarationStructure> & {
   extends?: string[];
@@ -84,22 +85,9 @@ export function emitTypes(
   context: SdkContext,
   { sourceRoot }: { sourceRoot: string }
 ) {
-  const { sdkPackage } = context;
   const outputProject = useContext("outputProject");
 
-  const modelsFilePath = getModelsPath(sourceRoot);
   let sourceFile;
-  if (
-    emitQueue.size > 0 &&
-    (sdkPackage.models.length > 0 || sdkPackage.enums.length > 0)
-  ) {
-    sourceFile = outputProject.createSourceFile(modelsFilePath);
-    if (!sourceFile) {
-      throw new Error(`Failed to create source file at ${modelsFilePath}`);
-    }
-  } else {
-    return;
-  }
 
   for (const type of emitQueue) {
     if (!isGenerableType(type)) {
@@ -108,19 +96,31 @@ export function emitTypes(
     if (isAzureCoreLroType(type.__raw)) {
       continue;
     }
+
+    const namespaces = getModelNamespaces(context, type);
+    const filepath = getModelsPath(sourceRoot, namespaces);
+    sourceFile = outputProject.getSourceFile(filepath);
+    if (!sourceFile) {
+      sourceFile = outputProject.createSourceFile(filepath);
+    }
     emitType(context, type, sourceFile);
   }
 
-  if (
-    sourceFile.getInterfaces().length === 0 &&
-    sourceFile.getTypeAliases().length === 0 &&
-    sourceFile.getEnums().length === 0
-  ) {
-    sourceFile.delete();
-    return;
+  const modelFiles = outputProject.getSourceFiles(
+    sourceRoot + "/models/**/*.ts"
+  );
+  for (const modelFile of modelFiles) {
+    if (
+      modelFile.getInterfaces().length === 0 &&
+      modelFile.getTypeAliases().length === 0 &&
+      modelFile.getEnums().length === 0
+    ) {
+      modelFile.delete();
+      return;
+    }
   }
-  addImportBySymbol("serializeRecord", sourceFile);
-  return sourceFile;
+
+  return modelFiles;
 }
 
 function emitType(context: SdkContext, type: SdkType, sourceFile: SourceFile) {
@@ -128,11 +128,15 @@ function emitType(context: SdkContext, type: SdkType, sourceFile: SourceFile) {
     if (isAzureCoreErrorType(context.program, type.__raw)) {
       return;
     }
+    if (isOrExtendsHttpFile(context.program, type.__raw!)) {
+      return;
+    }
     if (
       !type.usage ||
       (type.usage !== undefined &&
         (type.usage & UsageFlags.Output) !== UsageFlags.Output &&
-        (type.usage & UsageFlags.Input) !== UsageFlags.Input)
+        (type.usage & UsageFlags.Input) !== UsageFlags.Input &&
+        (type.usage & UsageFlags.Exception) !== UsageFlags.Exception)
     ) {
       return;
     }
@@ -175,7 +179,9 @@ function emitType(context: SdkContext, type: SdkType, sourceFile: SourceFile) {
     const apiVersionEnumOnly = type.usage === UsageFlags.ApiVersionEnum;
     const inputUsage = (type.usage & UsageFlags.Input) === UsageFlags.Input;
     const outputUsage = (type.usage & UsageFlags.Output) === UsageFlags.Output;
-    if (!(inputUsage || outputUsage || apiVersionEnumOnly)) {
+    const exceptionUsage =
+      (type.usage & UsageFlags.Exception) === UsageFlags.Exception;
+    if (!(inputUsage || outputUsage || apiVersionEnumOnly || exceptionUsage)) {
       return;
     }
     const [enumType, knownValuesEnum] = buildEnumTypes(context, type);
@@ -217,8 +223,49 @@ export function getApiVersionEnum(context: SdkContext) {
   return apiVersionEnum;
 }
 
-export function getModelsPath(sourceRoot: string): string {
-  return path.join(...[sourceRoot, "models", `models.ts`]);
+export function getModelsPath(
+  sourceRoot: string,
+  modelNamespace: string[] = []
+): string {
+  return path.join(
+    ...[
+      sourceRoot,
+      "models",
+      ...modelNamespace.map((n) => normalizeName(n, NameType.File)),
+      `models.ts`
+    ]
+  );
+}
+
+export function getModelNamespaces(
+  context: SdkContext,
+  model: SdkType
+): string[] {
+  const rootNamespace = context.sdkPackage.rootNamespace.split(".");
+  if (
+    model.kind === "model" ||
+    model.kind === "enum" ||
+    model.kind === "union"
+  ) {
+    if (
+      model.clientNamespace.startsWith("Azure.ResourceManager") ||
+      model.clientNamespace.startsWith("Azure.Core")
+    ) {
+      return [];
+    }
+    const segments = model.clientNamespace.split(".");
+    if (segments.length > rootNamespace.length) {
+      while (segments[0] === rootNamespace[0]) {
+        segments.shift();
+        rootNamespace.shift();
+      }
+      return segments;
+    }
+    return [];
+  } else if (model.kind === "array" || model.kind === "dict") {
+    return getModelNamespaces(context, model.valueType);
+  }
+  return [];
 }
 
 function addSerializationFunctions(
@@ -524,10 +571,52 @@ function buildModelProperty(
       target: NoTarget
     });
   }
+
+  let typeExpression: string;
+  if (property.kind === "property" && property.isMultipartFileInput) {
+    const multipartOptions = property.multipartOptions;
+    typeExpression = "{";
+    typeExpression += `contents: ${resolveReference(MultipartHelpers.FileContents)};`;
+
+    const isContentTypeOptional =
+      multipartOptions?.contentType === undefined ||
+      multipartOptions.contentType.optional ||
+      multipartOptions.defaultContentTypes.length > 0;
+    const isFilenameOptional =
+      multipartOptions?.filename === undefined ||
+      multipartOptions.filename.optional;
+
+    const contentTypeType = multipartOptions?.contentType
+      ? getTypeExpression(context, multipartOptions.contentType.type)
+      : "string";
+    const filenameType = multipartOptions?.filename
+      ? getTypeExpression(context, multipartOptions.filename.type)
+      : "string";
+
+    typeExpression += `contentType${isContentTypeOptional ? "?" : ""}: ${contentTypeType};`;
+    typeExpression += `filename${isFilenameOptional ? "?" : ""}: ${filenameType};`;
+
+    typeExpression += "}";
+
+    if (isContentTypeOptional && isFilenameOptional) {
+      // Allow passing content directly if both filename and content type are optional
+      typeExpression = `(${resolveReference(MultipartHelpers.FileContents)}) | ${typeExpression}`;
+    } else {
+      // If either one is required, still accept File at the top level since it requires a filename
+      typeExpression = `File | ${typeExpression}`;
+    }
+
+    if (property.type.kind === "array") {
+      typeExpression = `Array<${typeExpression}>`;
+    }
+  } else {
+    typeExpression = getTypeExpression(context, property.type);
+  }
+
   const propertyStructure: PropertySignatureStructure = {
     kind: StructureKind.PropertySignature,
     name: normalizedPropName,
-    type: getTypeExpression(context, property.type),
+    type: typeExpression,
     hasQuestionToken: property.optional,
     isReadonly: isReadOnly(property as SdkBodyModelPropertyType)
   };