@azure-tools/typespec-ts 0.15.0 → 0.16.0

package/src/modular/buildSubpathIndex.ts

@@ -1,20 +1,22 @@
 import { join } from "path";
-import { Project } from "ts-morph";
+import { Client, ModularCodeModel } from "./modularCodeModel.js";
 
 export function buildSubpathIndexFile(
-  project: Project,
-  srcPath: string,
-  subpath: string,
-  subfolder: string
+  codeModel: ModularCodeModel,
+  client: Client,
+  subpath: string
 ) {
-  const apiFilePattern = join(srcPath, subfolder, subpath);
-  const apiFiles = project.getSourceFiles().filter((file) => {
+  const { subfolder } = client;
+  const srcPath = codeModel.modularOptions.sourceRoot;
+
+  const apiFilePattern = join(srcPath, client.subfolder ?? "", subpath);
+  const apiFiles = codeModel.project.getSourceFiles().filter((file) => {
     return file
       .getFilePath()
       .replace(/\\/g, "/")
       .startsWith(apiFilePattern.replace(/\\/g, "/"));
   });
-  const indexFile = project.createSourceFile(
+  const indexFile = codeModel.project.createSourceFile(
     `${srcPath}/${subfolder}/${subpath}/index.ts`
   );
   for (const file of apiFiles) {

package/src/modular/emitModels.ts

@@ -1,4 +1,4 @@
-import { Project, SourceFile } from "ts-morph";
+import { SourceFile } from "ts-morph";
 import { getType } from "./helpers/typeHelpers.js";
 import { Client, ModularCodeModel, Type } from "./modularCodeModel.js";
 import * as path from "path";
@@ -10,18 +10,22 @@ import { buildOperationOptions } from "./buildOperations.js";
  */
 export function buildModels(
   codeModel: ModularCodeModel,
-  project: Project,
-  srcPath: string = "src",
-  subfolder: string = ""
-): SourceFile {
-  const modelsFile = project.createSourceFile(
-    path.join(`${srcPath}/`, subfolder, `models/models.ts`)
-  );
-
+  subClient: Client
+): SourceFile | undefined {
   // We are generating both models and enums here
   const coreClientTypes = new Set<string>();
   const models = codeModel.types.filter(
-    (t) => (t.type === "model" || t.type === "enum") && !isAzureCoreError(t)
+    (t) =>
+      (t.type === "model" || t.type === "enum") && !isAzureCoreErrorSdkType(t)
+  );
+
+  // Skip to generate models.ts if there is no any models
+  if (models.length === 0) {
+    return;
+  }
+  const srcPath = codeModel.modularOptions.sourceRoot;
+  const modelsFile = codeModel.project.createSourceFile(
+    path.join(`${srcPath}/`, subClient.subfolder ?? "", `models/models.ts`)
   );
 
   for (const model of codeModel.types) {
@@ -36,7 +40,7 @@ export function buildModels(
 
   for (const model of models) {
     const properties = model.properties ?? [];
-    const typeMetadata = getType(model);
+    const typeMetadata = getType(model, model.format);
     let typeName = typeMetadata.name;
     if (typeMetadata.modifier === "Array") {
       typeName = `${typeName}[]`;
@@ -67,15 +71,16 @@ export function buildModels(
       if (!model.name) {
         throw new Error("Can't generate a model that has no name");
       }
-      modelsFile.addInterface({
+      const modelInterface = {
         name: model.name,
         isExported: true,
         docs: getDocsFromDescription(model.description),
+        extends: [] as string[],
         properties: properties.map((p) => {
-          const propertyMetadata = getType(p.type);
+          const propertyMetadata = getType(p.type, p.format);
           let propertyTypeName = propertyMetadata.name;
-          if (isAzureCoreError(p.type)) {
-            propertyTypeName = isAzureCoreError(p.type)
+          if (isAzureCoreErrorSdkType(p.type)) {
+            propertyTypeName = isAzureCoreErrorSdkType(p.type)
               ? getCoreClientErrorType(propertyTypeName)
               : propertyTypeName;
           }
@@ -90,7 +95,13 @@ export function buildModels(
             type: propertyTypeName
           };
         })
-      });
+      };
+      model.type === "model"
+        ? model.parents?.forEach((p) =>
+            modelInterface.extends.push(getType(p, p.format).name)
+          )
+        : undefined;
+      modelsFile.addInterface(modelInterface);
     }
   }
 
@@ -112,22 +123,22 @@ export function buildModels(
   return modelsFile;
 }
 
-function isAzureCoreError(t: Type) {
+function isAzureCoreErrorSdkType(t: Type) {
   return (
     t.name &&
-    ["Error", "InnerError"].includes(t.name) &&
+    ["error", "errormodel", "innererror", "errorresponse"].includes(
+      t.name.toLowerCase()
+    ) &&
     t.isCoreErrorType === true
   );
 }
 
 export function buildModelsOptions(
-  client: Client,
-  project: Project,
-  srcPath: string = "src",
-  subfolder: string = ""
+  codeModel: ModularCodeModel,
+  client: Client
 ) {
-  const modelOptionsFile = project.createSourceFile(
-    `${srcPath}/${subfolder}/models/options.ts`,
+  const modelOptionsFile = codeModel.project.createSourceFile(
+    `${codeModel.modularOptions.sourceRoot}/${client.subfolder}/models/options.ts`,
     undefined,
     {
       overwrite: true

package/src/modular/helpers/clientHelpers.ts

@@ -24,7 +24,7 @@ export function getClientParameters(
       .map<OptionalKind<ParameterDeclarationStructure>>((p) => {
         return {
           name: p.clientName,
-          type: getType(p.type).name
+          type: getType(p.type, p.format).name
         };
       }),
     optionsParam