@azure-tools/typespec-ts 0.54.0 → 0.55.0-dev.6

package/src/rlc-common/buildObjectTypes.ts

@@ -6,14 +6,11 @@ import {
   OptionalKind,
   PropertySignatureStructure,
   StructureKind,
-  TypeAliasDeclarationStructure
+  TypeAliasDeclarationStructure,
 } from "ts-morph";
+import { getMultipartPartTypeName } from "./helpers/nameConstructors.js";
 import { NameType, normalizeName } from "./helpers/nameUtils.js";
-import {
-  isArraySchema,
-  isDictionarySchema,
-  isObjectSchema
-} from "./helpers/schemaHelpers.js";
+import { isArraySchema, isDictionarySchema, isObjectSchema } from "./helpers/schemaHelpers.js";
 import {
   ArraySchema,
   ObjectSchema,
@@ -21,9 +18,8 @@ import {
   Property,
   RLCModel,
   Schema,
-  SchemaContext
+  SchemaContext,
 } from "./interfaces.js";
-import { getMultipartPartTypeName } from "./helpers/nameConstructors.js";
 
 /**
  * Generates interfaces for ObjectSchemas
@@ -31,32 +27,22 @@ import { getMultipartPartTypeName } from "./helpers/nameConstructors.js";
 export function buildObjectInterfaces(
   model: RLCModel,
   importedModels: Set<string>,
-  schemaUsage: SchemaContext[]
+  schemaUsage: SchemaContext[],
 ): InterfaceDeclarationStructure[] {
   const objectSchemas: ObjectSchema[] = (model.schemas ?? []).filter(
-    (o) =>
-      isObjectSchema(o) &&
-      (o as ObjectSchema).usage?.some((u) => schemaUsage.includes(u))
+    (o) => isObjectSchema(o) && (o as ObjectSchema).usage?.some((u) => schemaUsage.includes(u)),
   );
   const objectInterfaces: InterfaceDeclarationStructure[] = [];
 
   for (const objectSchema of objectSchemas) {
-    if (
-      objectSchema.alias ||
-      objectSchema.outputAlias ||
-      objectSchema.fromCore
-    ) {
+    if (objectSchema.alias || objectSchema.outputAlias || objectSchema.fromCore) {
       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
-        )
+        ...buildMultipartPartDefinitions(objectSchema, importedModels, schemaUsage),
       );
       continue;
     }
@@ -67,7 +53,7 @@ export function buildObjectInterfaces(
       baseName,
       objectSchema,
       schemaUsage,
-      importedModels
+      importedModels,
     );
 
     objectInterfaces.push(interfaceDeclaration);
@@ -75,24 +61,23 @@ export function buildObjectInterfaces(
   return objectInterfaces;
 }
 
-const MULTIPART_FILE_METADATA_PROPERTIES: OptionalKind<PropertySignatureStructure>[] =
-  [
-    {
-      name: "filename",
-      hasQuestionToken: true,
-      type: "string"
-    },
-    {
-      name: "contentType",
-      hasQuestionToken: true,
-      type: "string"
-    }
-  ];
+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[]
+  schemaUsage: SchemaContext[],
 ): InterfaceDeclarationStructure[] {
   if (!schema.isMultipartBody) {
     return [];
@@ -103,7 +88,7 @@ function buildMultipartPartDefinitions(
     schema.properties ?? {},
     schemaUsage,
     importedModels,
-    { flattenBinaryArrays: true }
+    { flattenBinaryArrays: true },
   );
 
   const structures: InterfaceDeclarationStructure[] = [];
@@ -124,8 +109,8 @@ function buildMultipartPartDefinitions(
           getPropertySignature(
             { name: "filename", ...multipartOptions.filenameSchema },
             [SchemaContext.Input],
-            importedModels
-          )
+            importedModels,
+          ),
         );
       }
       if (multipartOptions.contentTypeSchema) {
@@ -133,8 +118,8 @@ function buildMultipartPartDefinitions(
           getPropertySignature(
             { name: "contentType", ...multipartOptions.contentTypeSchema },
             [SchemaContext.Input],
-            importedModels
-          )
+            importedModels,
+          ),
         );
       }
     } else if (isFileUpload) {
@@ -149,14 +134,14 @@ function buildMultipartPartDefinitions(
       properties: [
         {
           name: "name",
-          type: name
+          type: name,
         },
         {
           name: "body",
-          type: signature.type
+          type: signature.type,
         },
-        ...additionalProperties
-      ]
+        ...additionalProperties,
+      ],
     });
   }
 
@@ -166,12 +151,10 @@ function buildMultipartPartDefinitions(
 export function buildObjectAliases(
   model: RLCModel,
   importedModels: Set<string>,
-  schemaUsage: SchemaContext[]
+  schemaUsage: SchemaContext[],
 ) {
   const objectSchemas: ObjectSchema[] = (model.schemas ?? []).filter(
-    (o) =>
-      isObjectSchema(o) &&
-      (o as ObjectSchema).usage?.some((u) => schemaUsage.includes(u))
+    (o) => isObjectSchema(o) && (o as ObjectSchema).usage?.some((u) => schemaUsage.includes(u)),
   );
   const objectAliases: TypeAliasDeclarationStructure[] = [];
 
@@ -182,21 +165,21 @@ export function buildObjectAliases(
         objectSchema.properties ?? {},
         schemaUsage,
         importedModels,
-        { flattenBinaryArrays: true }
+        { flattenBinaryArrays: true },
       );
 
       const objectTypeNames = propertySignatures.map((sig) =>
-        getMultipartPartTypeName(objectSchema.name, sig.name)
+        getMultipartPartTypeName(objectSchema.name, sig.name),
       );
 
       objectAliases.push({
         kind: StructureKind.TypeAlias,
         ...(objectSchema.description && {
-          docs: [{ description: objectSchema.description }]
+          docs: [{ description: objectSchema.description }],
         }),
         name: objectSchema.typeName!,
         type: `FormData | Array<${objectTypeNames.join("|") || "unknown"}>`,
-        isExported: true
+        isExported: true,
       });
     }
 
@@ -213,31 +196,22 @@ export function buildObjectAliases(
           ? `${objectSchema.alias}`
           : `${objectSchema.outputAlias}`,
         isExported: true,
-        docs: [description ?? "Alias for " + modelName]
+        docs: [description ?? "Alias for " + modelName],
       });
     }
   }
   return objectAliases;
 }
 
-export function buildPolymorphicAliases(
-  model: RLCModel,
-  schemaUsage: SchemaContext[]
-) {
+export function buildPolymorphicAliases(model: RLCModel, schemaUsage: SchemaContext[]) {
   // We'll add aliases for polymorphic objects
   const objectAliases: TypeAliasDeclarationStructure[] = [];
   const objectSchemas: ObjectSchema[] = (model.schemas ?? []).filter(
-    (o) =>
-      isObjectSchema(o) &&
-      (o as ObjectSchema).usage?.some((u) => schemaUsage.includes(u))
+    (o) => isObjectSchema(o) && (o as ObjectSchema).usage?.some((u) => schemaUsage.includes(u)),
   );
   for (const objectSchema of objectSchemas) {
     const baseName = getObjectBaseName(objectSchema, schemaUsage);
-    const typeAlias = getPolymorphicTypeAlias(
-      baseName,
-      objectSchema,
-      schemaUsage
-    );
+    const typeAlias = getPolymorphicTypeAlias(baseName, objectSchema, schemaUsage);
     if (typeAlias) {
       objectAliases.push(typeAlias);
     }
@@ -249,16 +223,9 @@ export function buildPolymorphicAliases(
 /**
  * Gets a base name for an object schema this is tipically used with suffixes when building interface or type names
  */
-function getObjectBaseName(
-  objectSchema: ObjectSchema,
-  schemaUsage: SchemaContext[]
-) {
+function getObjectBaseName(objectSchema: ObjectSchema, schemaUsage: SchemaContext[]) {
   const nameSuffix = schemaUsage.includes(SchemaContext.Output) ? "Output" : "";
-  const name = normalizeName(
-    objectSchema.name,
-    NameType.Interface,
-    true /** guard name */
-  );
+  const name = normalizeName(objectSchema.name, NameType.Interface, true /** guard name */);
 
   return `${name}${nameSuffix}`;
 }
@@ -270,7 +237,7 @@ function getObjectBaseName(
 function getPolymorphicTypeAlias(
   baseName: string,
   objectSchema: ObjectSchema,
-  schemaUsage: SchemaContext[]
+  schemaUsage: SchemaContext[],
 ): TypeAliasDeclarationStructure | undefined {
   if (!isPolymorphicParent(objectSchema)) {
     return undefined;
@@ -284,14 +251,8 @@ function getPolymorphicTypeAlias(
   }
 
   for (const child of objectSchema.children?.all ?? []) {
-    const nameSuffix = schemaUsage.includes(SchemaContext.Output)
-      ? "Output"
-      : "";
-    const name = normalizeName(
-      child.name,
-      NameType.Interface,
-      true /** shouldGuard */
-    );
+    const nameSuffix = schemaUsage.includes(SchemaContext.Output) ? "Output" : "";
+    const name = normalizeName(child.name, NameType.Interface, true /** shouldGuard */);
 
     unionTypes.push(`${name}${nameSuffix}`);
   }
@@ -303,7 +264,7 @@ function getPolymorphicTypeAlias(
     ...(description && { docs: [{ description }] }),
     name: `${baseName}`,
     type: unionTypes.join(" | "),
-    isExported: true
+    isExported: true,
   };
 }
 
@@ -316,7 +277,7 @@ export function getObjectInterfaceDeclaration(
   baseName: string,
   objectSchema: ObjectSchema,
   schemaUsage: SchemaContext[],
-  importedModels: Set<string>
+  importedModels: Set<string>,
 ): InterfaceDeclarationStructure {
   let interfaceName = `${baseName}`;
   if (isPolymorphicParent(objectSchema)) {
@@ -325,18 +286,14 @@ export function getObjectInterfaceDeclaration(
 
   const properties = objectSchema.properties ?? {};
 
-  let propertySignatures = getPropertySignatures(
-    properties,
-    schemaUsage,
-    importedModels
-  );
+  let propertySignatures = getPropertySignatures(properties, schemaUsage, importedModels);
 
   // Add the polymorphic property if exists
   propertySignatures = addDiscriminatorProperty(
     model,
     objectSchema,
     propertySignatures,
-    schemaUsage
+    schemaUsage,
   );
 
   // Calculate the parents of the current object
@@ -349,7 +306,7 @@ export function getObjectInterfaceDeclaration(
     name: interfaceName,
     isExported: true,
     properties: propertySignatures,
-    ...(extendFrom && { extends: extendFrom })
+    ...(extendFrom && { extends: extendFrom }),
   };
 }
 
@@ -361,21 +318,15 @@ function addDiscriminatorProperty(
   model: RLCModel,
   objectSchema: ObjectSchema,
   properties: PropertySignatureStructure[],
-  schemaUsage: SchemaContext[]
+  schemaUsage: SchemaContext[],
 ): PropertySignatureStructure[] {
-  const polymorphicProperty = getDiscriminatorProperty(
-    model,
-    objectSchema,
-    schemaUsage
-  );
+  const polymorphicProperty = getDiscriminatorProperty(model, objectSchema, schemaUsage);
 
   if (polymorphicProperty) {
     // It is possible that the polymorphic property needs to override an existing property.
     // This is usually the case on the top level parent where the property already has a type of string
     // we need to replace it with the polymorphic values of its children
-    const filteredProperties = properties.filter(
-      (p) => p.name !== polymorphicProperty.name
-    );
+    const filteredProperties = properties.filter((p) => p.name !== polymorphicProperty.name);
     return [...filteredProperties, polymorphicProperty];
   }
 
@@ -388,7 +339,7 @@ function addDiscriminatorProperty(
 function getDiscriminatorProperty(
   model: RLCModel,
   objectSchema: ObjectSchema,
-  schemaUsage: SchemaContext[]
+  schemaUsage: SchemaContext[],
 ): PropertySignatureStructure | undefined {
   const discriminatorValue = objectSchema.discriminatorValue;
   if (!discriminatorValue && !objectSchema.discriminator) {
@@ -401,11 +352,10 @@ function getDiscriminatorProperty(
   if (discriminators) {
     if (discriminatorPropertyName === undefined) {
       throw new Error(
-        `getDiscriminatorProperty: Expected object ${objectSchema.name} to have a discriminator in its hierarchy but found none`
+        `getDiscriminatorProperty: Expected object ${objectSchema.name} to have a discriminator in its hierarchy but found none`,
       );
     }
-    const inputTypeName =
-      objectSchema.discriminator?.typeName ?? objectSchema.discriminator?.type;
+    const inputTypeName = objectSchema.discriminator?.typeName ?? objectSchema.discriminator?.type;
     return {
       kind: StructureKind.PropertySignature,
       name: `"${discriminatorPropertyName}"`,
@@ -414,7 +364,7 @@ function getDiscriminatorProperty(
           ? discriminators
           : schemaUsage.includes(SchemaContext.Output)
             ? (objectSchema.discriminator?.outputTypeName ?? inputTypeName)
-            : inputTypeName
+            : inputTypeName,
     };
   }
 
@@ -468,13 +418,9 @@ function getDiscriminatorValue(objectSchema: ObjectSchema): string | undefined {
     const allChildren = objectSchema.children?.all ?? [];
 
     // Top level parents may not have a discriminator of their own.
-    const selfDiscriminator = discriminatorValue
-      ? [`"${discriminatorValue}"`]
-      : [];
+    const selfDiscriminator = discriminatorValue ? [`"${discriminatorValue}"`] : [];
 
-    const childValues = getChildDiscriminatorValues(allChildren).map(
-      (v) => `"${v}"`
-    );
+    const childValues = getChildDiscriminatorValues(allChildren).map((v) => `"${v}"`);
 
     return [...selfDiscriminator, ...childValues].join(" | ");
   }
@@ -501,7 +447,7 @@ function getChildDiscriminatorValues(children: ObjectSchema[]): string[] {
  */
 export function getImmediateParentsNames(
   objectSchema: ObjectSchema,
-  schemaUsage: SchemaContext[]
+  schemaUsage: SchemaContext[],
 ): string[] {
   if (!objectSchema.parents?.immediate) {
     return [];
@@ -511,11 +457,7 @@ export function getImmediateParentsNames(
 
   // If an immediate parent is an empty DictionarySchema, that means that the object has been marked
   // with additional properties. We need to add Record<string, unknown> to the extend list and
-  if (
-    objectSchema.parents.immediate.find((im) =>
-      isDictionarySchema(im, { filterEmpty: true })
-    )
-  ) {
+  if (objectSchema.parents.immediate.find((im) => isDictionarySchema(im, { filterEmpty: true }))) {
     extendFrom.push("Record<string, unknown>");
   }
 
@@ -523,17 +465,13 @@ export function getImmediateParentsNames(
   const parents = objectSchema.parents.immediate
     .filter((p) => !isDictionarySchema(p, { filterEmpty: true }))
     .map((parent) => {
-      const nameSuffix = schemaUsage.includes(SchemaContext.Output)
-        ? "Output"
-        : "";
+      const nameSuffix = schemaUsage.includes(SchemaContext.Output) ? "Output" : "";
       const name = isDictionarySchema(parent)
         ? Object.entries(objectSchema.properties!)?.some((prop) => {
             const typeName = prop[1].typeName ?? prop[1].type;
             return (
               `Record<string, ${typeName}>` !== parent.typeName &&
-              !(parent as any).additionalProperties?.typeName?.includes(
-                typeName
-              )
+              !(parent as any).additionalProperties?.typeName?.includes(typeName)
             );
           })
           ? schemaUsage.includes(SchemaContext.Output)
@@ -544,15 +482,9 @@ export function getImmediateParentsNames(
                 ? parent.outputTypeName
                 : parent.typeName) ?? parent.name
             }`
-        : `${normalizeName(
-            parent.name,
-            NameType.Interface,
-            true /** shouldGuard */
-          )}${nameSuffix}`;
-
-      return isObjectSchema(parent) && isPolymorphicParent(parent)
-        ? `${name}Parent`
-        : name;
+        : `${normalizeName(parent.name, NameType.Interface, true /** shouldGuard */)}${nameSuffix}`;
+
+      return isObjectSchema(parent) && isPolymorphicParent(parent) ? `${name}Parent` : name;
     });
 
   return [...parents, ...extendFrom];
@@ -566,7 +498,7 @@ function getPropertySignatures(
   properties: { [key: string]: Property },
   schemaUsage: SchemaContext[],
   importedModels: Set<string>,
-  options: GetPropertySignatureOptions = {}
+  options: GetPropertySignatureOptions = {},
 ) {
   let validProperties = Object.keys(properties);
   const readOnlyFilter = (name: string) => {
@@ -587,7 +519,7 @@ function getPropertySignatures(
       { ...prop, name: p } as Schema,
       schemaUsage,
       importedModels,
-      options
+      options,
     );
   });
 }
@@ -595,8 +527,8 @@ function getPropertySignatures(
 function isBinaryArray(schema: Schema): boolean {
   return Boolean(
     isArraySchema(schema) &&
-    (schema.items?.typeName?.includes("NodeJS.ReadableStream") ||
-      schema.items?.outputTypeName?.includes("NodeJS.ReadableStream"))
+    (schema.items?.typeName?.includes("NodeReadableStream") ||
+      schema.items?.outputTypeName?.includes("NodeReadableStream")),
   );
 }
 
@@ -610,13 +542,13 @@ export function getPropertySignature(
   property: Property | Parameter,
   schemaUsage: SchemaContext[],
   importedModels: Set<string>,
-  options: GetPropertySignatureOptions = {}
+  options: GetPropertySignatureOptions = {},
 ): PropertySignatureStructure {
   let schema: Schema;
   if (options.flattenBinaryArrays && isBinaryArray(property)) {
     schema = {
       ...((property as ArraySchema).items ?? property),
-      name: property.name
+      name: property.name,
     };
   } else {
     schema = property;
@@ -626,23 +558,18 @@ export function getPropertySignature(
   const description = schema.description;
   let type;
   const hasCoreInArray =
-    schema.type === "array" &&
-    (schema as any).items &&
-    (schema as any).items.fromCore;
+    schema.type === "array" && (schema as any).items && (schema as any).items.fromCore;
   const hasCoreInRecord =
     schema.type === "dictionary" &&
     (schema as any).additionalProperties &&
     (schema as any).additionalProperties.fromCore;
   if (hasCoreInArray && schema.typeName) {
     type = schema.typeName;
-    importedModels.add(
-      (schema as any).items.typeName ?? (schema as any).items.name
-    );
+    importedModels.add((schema as any).items.typeName ?? (schema as any).items.name);
   } else if (hasCoreInRecord && schema.typeName) {
     type = schema.typeName;
     importedModels.add(
-      (schema as any).additionalProperties.typeName ??
-        (schema as any).additionalProperties.name
+      (schema as any).additionalProperties.typeName ?? (schema as any).additionalProperties.name,
     );
   } else {
     type =
@@ -663,17 +590,13 @@ export function getPropertySignature(
     hasQuestionToken: !schema.required,
     isReadonly: generateForOutput(schemaUsage, schema.usage) && schema.readOnly,
     type,
-    kind: StructureKind.PropertySignature
+    kind: StructureKind.PropertySignature,
   };
 }
 
-function generateForOutput(
-  schemaUsage: SchemaContext[],
-  propertyUsage?: SchemaContext[]
-) {
+function generateForOutput(schemaUsage: SchemaContext[], propertyUsage?: SchemaContext[]) {
   return (
-    (schemaUsage.includes(SchemaContext.Output) &&
-      propertyUsage?.includes(SchemaContext.Output)) ||
+    (schemaUsage.includes(SchemaContext.Output) && propertyUsage?.includes(SchemaContext.Output)) ||
     (schemaUsage.includes(SchemaContext.Exception) &&
       propertyUsage?.includes(SchemaContext.Exception))
   );

package/src/rlc-common/buildPaginateHelper.ts

@@ -1,5 +1,5 @@
-import { RLCModel } from "./interfaces.js";
 import * as path from "path";
+import { RLCModel } from "./interfaces.js";
 // eslint-disable-next-line @typescript-eslint/ban-ts-comment
 // @ts-ignore: to fix the handlebars issue
 import hbs from "handlebars";
@@ -12,23 +12,20 @@ export function buildPaginateHelper(model: RLCModel) {
     return;
   }
 
-  hbs.registerHelper(
-    "quoteWrap",
-    function (value: string | number | boolean | string[]) {
-      if (Array.isArray(value)) {
-        return value.map((element) => `"${element}"`).join();
-      }
-
-      return `"${value}"`;
+  hbs.registerHelper("quoteWrap", function (value: string | number | boolean | string[]) {
+    if (Array.isArray(value)) {
+      return value.map((element) => `"${element}"`).join();
     }
-  );
+
+    return `"${value}"`;
+  });
 
   const { srcPath } = model;
   const paginateHelperContents = hbs.compile(paginateContent, {
-    noEscape: true
+    noEscape: true,
   });
   return {
     path: path.join(srcPath, "paginateHelper.ts"),
-    content: paginateHelperContents(pagingInfo.pageDetails)
+    content: paginateHelperContents(pagingInfo.pageDetails),
   };
 }