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

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

@@ -12,34 +12,25 @@ export function getResponseTypeName(baseResponseName: string): string;
 export function getResponseTypeName(
   operationGroup: string,
   operationName: string,
-  statusCode: string
+  statusCode: string,
 ): string;
 export function getResponseTypeName(
   baseNameOrOperationGroup: string,
   operationName?: string,
-  statusCode?: string
+  statusCode?: string,
 ): string {
   if (operationName) {
     baseNameOrOperationGroup = getResponseBaseName(
       baseNameOrOperationGroup,
       operationName!,
-      statusCode || ""
+      statusCode || "",
     );
   }
-  return normalizeName(
-    `${baseNameOrOperationGroup}Response`,
-    NameType.Interface
-  );
+  return normalizeName(`${baseNameOrOperationGroup}Response`, NameType.Interface);
 }
 
-export function getLroLogicalResponseName(
-  operationGroup: string,
-  operationName: string
-) {
-  return normalizeName(
-    `${operationGroup}_${operationName}_Logical_Response`,
-    NameType.Interface
-  );
+export function getLroLogicalResponseName(operationGroup: string, operationName: string) {
+  return normalizeName(`${operationGroup}_${operationName}_Logical_Response`, NameType.Interface);
 }
 
 /**
@@ -52,15 +43,11 @@ export function getLroLogicalResponseName(
 export function getResponseBaseName(
   operationGroup: string,
   operationName: string,
-  statusCode: string
+  statusCode: string,
 ) {
   return normalizeName(
-    `${operationGroup}_${normalizeName(
-      operationName,
-      NameType.Interface,
-      true
-    )}_${statusCode}`,
-    NameType.Interface
+    `${operationGroup}_${normalizeName(operationName, NameType.Interface, true)}_${statusCode}`,
+    NameType.Interface,
   );
 }
 
@@ -69,14 +56,8 @@ export function getResponseBaseName(
  * @param operationName is composed with operationGroup and operationID e.g string_PutEmpty
  * @returns
  */
-export function getParameterBaseName(
-  operationGroup: string,
-  operationName: string
-) {
-  return normalizeName(
-    `${operationGroup}_${operationName}`,
-    NameType.Interface
-  );
+export function getParameterBaseName(operationGroup: string, operationName: string) {
+  return normalizeName(`${operationGroup}_${operationName}`, NameType.Interface);
 }
 
 /**
@@ -86,25 +67,13 @@ export function getParameterBaseName(
  * @returns top-layer parameter name e.g StringPutEmptParameters
  */
 export function getParameterTypeName(baseName: string): string;
-export function getParameterTypeName(
-  operationGroup: string,
-  operationName: string
-): string;
-export function getParameterTypeName(
-  baseNameOrOperationGroup: string,
-  operationName?: string
-) {
+export function getParameterTypeName(operationGroup: string, operationName: string): string;
+export function getParameterTypeName(baseNameOrOperationGroup: string, operationName?: string) {
   if (operationName) {
-    baseNameOrOperationGroup = getParameterBaseName(
-      baseNameOrOperationGroup,
-      operationName!
-    );
+    baseNameOrOperationGroup = getParameterBaseName(baseNameOrOperationGroup, operationName!);
   }
 
-  return normalizeName(
-    `${baseNameOrOperationGroup}_Parameters`,
-    NameType.Interface
-  );
+  return normalizeName(`${baseNameOrOperationGroup}_Parameters`, NameType.Interface);
 }
 
 export interface ModuleName {
@@ -137,8 +106,5 @@ 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
-  );
+  return normalizeName(`${bodyParamName}_${name}_PartDescriptor`, NameType.Interface);
 }

package/src/rlc-common/helpers/nameUtils.ts

@@ -22,7 +22,7 @@ export enum NameType {
   Operation,
   OperationGroup,
   Method,
-  EnumMemberName
+  EnumMemberName,
 }
 
 const Newable = [NameType.Class, NameType.Interface, NameType.OperationGroup];
@@ -47,7 +47,7 @@ export const ReservedModelNames: ReservedName[] = [
   { name: "default", reservedFor: [NameType.Parameter, NameType.Method] },
   {
     name: "delete",
-    reservedFor: [NameType.Parameter, NameType.Operation, NameType.Method]
+    reservedFor: [NameType.Parameter, NameType.Operation, NameType.Method],
   },
   { name: "do", reservedFor: [NameType.Parameter, NameType.Method] },
   { name: "else", reservedFor: [NameType.Parameter, NameType.Method] },
@@ -55,7 +55,7 @@ export const ReservedModelNames: ReservedName[] = [
   { name: "error", reservedFor: [NameType.Parameter, ...Newable] },
   {
     name: "export",
-    reservedFor: [NameType.Parameter, NameType.Operation, NameType.Method]
+    reservedFor: [NameType.Parameter, NameType.Operation, NameType.Method],
   },
   { name: "extends", reservedFor: [NameType.Parameter, NameType.Method] },
   { name: "false", reservedFor: [NameType.Parameter, NameType.Method] },
@@ -64,7 +64,7 @@ export const ReservedModelNames: ReservedName[] = [
   { name: "from", reservedFor: [NameType.Parameter] },
   {
     name: "function",
-    reservedFor: [NameType.Parameter, ...Newable, NameType.Method]
+    reservedFor: [NameType.Parameter, ...Newable, NameType.Method],
   },
   { name: "get", reservedFor: [NameType.Parameter] },
   { name: "if", reservedFor: [NameType.Parameter, NameType.Method] },
@@ -84,7 +84,7 @@ export const ReservedModelNames: ReservedName[] = [
   { name: "protected", reservedFor: [NameType.Parameter] },
   {
     name: "public",
-    reservedFor: [NameType.Parameter, NameType.Operation, NameType.Method]
+    reservedFor: [NameType.Parameter, NameType.Operation, NameType.Method],
   },
   { name: "requestoptions", reservedFor: [NameType.Parameter] },
   { name: "require", reservedFor: [NameType.Parameter, NameType.Method] },
@@ -111,18 +111,18 @@ export const ReservedModelNames: ReservedName[] = [
   // reserve client for codegen
   { name: "client", reservedFor: [NameType.Parameter] },
   { name: "endpoint", reservedFor: [NameType.Parameter] },
-  { name: "apiVersion", reservedFor: [NameType.Parameter] }
+  { name: "apiVersion", reservedFor: [NameType.Parameter] },
 ];
 
 export enum CasingConvention {
   Pascal,
-  Camel
+  Camel,
 }
 
 export function guardReservedNames(
   name: string,
   nameType: NameType,
-  customReservedNames: ReservedName[] = []
+  customReservedNames: ReservedName[] = [],
 ): string {
   const [prefix, suffix] = getAffix(nameType);
   return [...ReservedModelNames, ...customReservedNames]
@@ -158,12 +158,12 @@ export function normalizeName(
   shouldGuard?: boolean,
   customReservedNames?: ReservedName[],
   casingOverride?: CasingConvention,
-  oriName?: string
+  oriName?: string,
 ): string;
 export function normalizeName(
   name: string,
   nameType: NameType,
-  options?: NormalizeNameOption
+  options?: NormalizeNameOption,
 ): string;
 export function normalizeName(
   name: string,
@@ -171,7 +171,7 @@ export function normalizeName(
   optionsOrShouldGuard?: NormalizeNameOption | boolean,
   optionalCustomReservedNames?: ReservedName[],
   optionalCasingOverride?: CasingConvention,
-  oriName?: string
+  oriName?: string,
 ): string {
   let shouldGuard: boolean | undefined,
     customReservedNames: ReservedName[],
@@ -208,11 +208,7 @@ export function normalizeName(
   return fixLeadingNumber(result, nameType, numberPrefixOverride);
 }
 
-export function fixLeadingNumber(
-  name: string,
-  nameType: NameType,
-  prefix: string = "_"
-): string {
+export function fixLeadingNumber(name: string, nameType: NameType, prefix: string = "_"): string {
   const casingConvention = getCasingConvention(nameType);
   if (!name || !name.match(/^[-.]?\d/)) {
     return name;
@@ -220,16 +216,10 @@ export function fixLeadingNumber(
   return `${toCasing(prefix, casingConvention)}${name}`;
 }
 
-function isFullyUpperCase(
-  identifier: string,
-  maxUppercasePreserve: number = 3
-) {
+function isFullyUpperCase(identifier: string, maxUppercasePreserve: number = 3) {
   const len = identifier.length;
   if (len > 1) {
-    if (
-      len <= maxUppercasePreserve &&
-      identifier === identifier.toUpperCase()
-    ) {
+    if (len <= maxUppercasePreserve && identifier === identifier.toUpperCase()) {
       return true;
     }
 
@@ -283,19 +273,11 @@ function getCasingConvention(nameType: NameType) {
   }
 }
 
-function toCasing(
-  str: string,
-  casing: CasingConvention,
-  keepConsistent = false
-): string {
+function toCasing(str: string, casing: CasingConvention, keepConsistent = false): string {
   const firstChar =
-    casing === CasingConvention.Pascal
-      ? str.charAt(0).toUpperCase()
-      : str.charAt(0).toLowerCase();
+    casing === CasingConvention.Pascal ? str.charAt(0).toUpperCase() : str.charAt(0).toLowerCase();
   const allLowerCases =
-    casing !== CasingConvention.Pascal &&
-    keepConsistent &&
-    str.toUpperCase() === str;
+    casing !== CasingConvention.Pascal && keepConsistent && str.toUpperCase() === str;
   return allLowerCases ? str.toLowerCase() : `${firstChar}${str.substring(1)}`;
 }
 
@@ -303,14 +285,9 @@ export function pascalCase(str: string) {
   return str.charAt(0).toUpperCase() + str.slice(1);
 }
 
-export function camelCase(
-  str: string,
-  options: { uppercaseThreshold?: number } = {}
-) {
+export function camelCase(str: string, options: { uppercaseThreshold?: number } = {}) {
   const { uppercaseThreshold = 4 } = options;
-  const thresholdRegex = new RegExp(
-    `^(?<![A-Z])[A-Z]{1,${uppercaseThreshold}}(?![A-Z])`
-  );
+  const thresholdRegex = new RegExp(`^(?<![A-Z])[A-Z]{1,${uppercaseThreshold}}(?![A-Z])`);
   if (!thresholdRegex.test(str)) {
     return str;
   }

package/src/rlc-common/helpers/operationHelpers.ts

@@ -1,11 +1,7 @@
 // Copyright (c) Microsoft Corporation.
 // Licensed under the MIT License.
 
-import {
-  MethodSignatureStructure,
-  OptionalKind,
-  ParameterDeclarationStructure
-} from "ts-morph";
+import { MethodSignatureStructure, OptionalKind, ParameterDeclarationStructure } from "ts-morph";
 import {
   Methods,
   ObjectSchema,
@@ -13,14 +9,14 @@ import {
   PathParameter,
   RLCModel,
   Schema,
-  SchemaContext
+  SchemaContext,
 } from "../interfaces.js";
 import { NameType, normalizeName, pascalCase } from "./nameUtils.js";
 import { isObjectSchema } from "./schemaHelpers.js";
 
 export function buildMethodDefinitions(
   methods: Methods,
-  pathParams: PathParameter[] = []
+  pathParams: PathParameter[] = [],
 ): OptionalKind<MethodSignatureStructure>[] {
   const methodDefinitions: OptionalKind<MethodSignatureStructure>[] = [];
   for (const key of Object.keys(methods)) {
@@ -40,10 +36,10 @@ export function buildMethodDefinitions(
           {
             name: "options",
             hasQuestionToken: areAllOptional,
-            type: pascalCase(method.optionsName)
-          }
+            type: pascalCase(method.optionsName),
+          },
         ],
-        returnType: `StreamableMethod<${method.returnType}>`
+        returnType: `StreamableMethod<${method.returnType}>`,
       });
     }
   }
@@ -52,13 +48,13 @@ export function buildMethodDefinitions(
 }
 
 export function getPathParamDefinitions(
-  pathParams: PathParameter[]
+  pathParams: PathParameter[],
 ): OptionalKind<ParameterDeclarationStructure>[] {
   return pathParams.map(({ name, type, description }) => {
     return {
       name: normalizeName(name, NameType.Parameter),
       type,
-      description
+      description,
     };
   });
 }
@@ -114,33 +110,22 @@ export function hasInputModels(model: RLCModel) {
   return hasSchemaContextObject(model, [SchemaContext.Input]);
 }
 export function hasOutputModels(model: RLCModel) {
-  return hasSchemaContextObject(model, [
-    SchemaContext.Output,
-    SchemaContext.Exception
-  ]);
+  return hasSchemaContextObject(model, [SchemaContext.Output, SchemaContext.Exception]);
 }
 
 function hasSchemaContextObject(model: RLCModel, 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)),
   );
 
   return objectSchemas.length > 0;
 }
 
-export function getGeneratedWrapperTypes(
-  params: ParameterMetadata[] | PathParameter[]
-): Schema[] {
+export function getGeneratedWrapperTypes(params: ParameterMetadata[] | PathParameter[]): Schema[] {
   const wrapperTypes = params
-    .map((qp) =>
-      isParameterMetadata(qp) ? qp.param.wrapperType : qp.wrapperType
-    )
+    .map((qp) => (isParameterMetadata(qp) ? qp.param.wrapperType : qp.wrapperType))
     .filter((v) => v !== undefined);
-  const wrapperFromObjects = wrapperTypes.filter(
-    (wrap) => wrap.type === "object"
-  );
+  const wrapperFromObjects = wrapperTypes.filter((wrap) => wrap.type === "object");
   const wrapperFromUnions = wrapperTypes
     .filter((wrap) => wrap.type === "union")
     .flatMap((wrapperType) => wrapperType?.enum ?? [])
@@ -148,8 +133,6 @@ export function getGeneratedWrapperTypes(
   return [...wrapperFromUnions, ...wrapperFromObjects];
 }
 
-function isParameterMetadata(
-  param: ParameterMetadata | PathParameter
-): param is ParameterMetadata {
+function isParameterMetadata(param: ParameterMetadata | PathParameter): param is ParameterMetadata {
   return (param as any).param !== undefined;
 }

package/src/rlc-common/helpers/pathUtils.ts

@@ -1,15 +1,10 @@
 import * as path from "path";
 
-export function getRelativePartFromSrcPath(
-  srcPath: string,
-  isModularLibrary: boolean = false
-) {
+export function getRelativePartFromSrcPath(srcPath: string, isModularLibrary: boolean = false) {
   const sep = srcPath.includes(path.sep + "src") ? path.sep : "/";
   let relativePart = srcPath.substring(srcPath.indexOf(sep + "src") + 4);
   if (isModularLibrary) {
     relativePart = relativePart.substring(srcPath.indexOf(sep + "rest"), +5);
   }
-  return relativePart.startsWith(sep)
-    ? relativePart.substring(1)
-    : relativePart;
+  return relativePart.startsWith(sep) ? relativePart.substring(1) : relativePart;
 }

package/src/rlc-common/helpers/schemaHelpers.ts

@@ -1,28 +1,17 @@
 // Copyright (c) Microsoft Corporation.
 // Licensed under the MIT License.
 
-import {
-  ArraySchema,
-  ObjectSchema,
-  RLCModel,
-  Schema,
-  SchemaContext
-} from "../interfaces.js";
+import { ArraySchema, ObjectSchema, RLCModel, Schema, SchemaContext } from "../interfaces.js";
 
 export interface IsDictionaryOptions {
   filterEmpty?: boolean;
 }
 
 export function isArraySchema(schema: Schema): schema is ArraySchema {
-  return (
-    schema.type === "array" || typeof (schema as any).items !== "undefined"
-  );
+  return schema.type === "array" || typeof (schema as any).items !== "undefined";
 }
 
-export function isDictionarySchema(
-  schema: Schema,
-  options: IsDictionaryOptions = {}
-) {
+export function isDictionarySchema(schema: Schema, options: IsDictionaryOptions = {}) {
   if (schema.type === "dictionary") {
     if (!options.filterEmpty || (options.filterEmpty && !schema.typeName)) {
       return true;
@@ -51,7 +40,7 @@ export function buildSchemaObjectMap(model: RLCModel) {
   const allSchemas = (model.schemas ?? []).filter(
     (o) =>
       isObjectSchema(o) &&
-      (o as ObjectSchema).usage?.some((u) => [SchemaContext.Input].includes(u))
+      (o as ObjectSchema).usage?.some((u) => [SchemaContext.Input].includes(u)),
   );
   allSchemas.forEach((o) => {
     map.set(o.name, o);

package/src/rlc-common/helpers/shortcutMethods.ts

@@ -1,17 +1,13 @@
 // Copyright (c) Microsoft Corporation.
 // Licensed under the MIT License.
 
-import {
-  OptionalKind,
-  MethodSignatureStructure,
-  InterfaceDeclarationStructure
-} from "ts-morph";
+import { InterfaceDeclarationStructure, MethodSignatureStructure, OptionalKind } from "ts-morph";
 import { PathMetadata, Paths } from "../interfaces.js";
-import { buildMethodDefinitions } from "./operationHelpers.js";
 import { NameType, normalizeName } from "./nameUtils.js";
+import { buildMethodDefinitions } from "./operationHelpers.js";
 
 export function generateMethodShortcuts(
-  paths: Paths
+  paths: Paths,
 ): OptionalKind<InterfaceDeclarationStructure>[] {
   const keys: Record<string, OptionalKind<MethodSignatureStructure>[]> = {};
   for (const path in paths) {
@@ -36,16 +32,14 @@ export function generateMethodShortcuts(
       name: `${interfaceName}Operations`,
       methods: methods,
       isExported: true,
-      docs: [`Contains operations for ${interfaceName} operations`]
+      docs: [`Contains operations for ${interfaceName} operations`],
     });
   }
 
   return interfaces;
 }
 
-function buildOperationDefinitions(
-  path: PathMetadata
-): OptionalKind<MethodSignatureStructure>[] {
+function buildOperationDefinitions(path: PathMetadata): OptionalKind<MethodSignatureStructure>[] {
   let ops: OptionalKind<MethodSignatureStructure>[] = [];
 
   for (const verb in path.methods) {
@@ -56,10 +50,7 @@ function buildOperationDefinitions(
     for (const method of methods) {
       const name = normalizeName(method.operationName, NameType.Property);
       const pathParams = path.pathParameters;
-      const methodDefinitions = buildMethodDefinitions(
-        { [name]: [method] },
-        pathParams
-      );
+      const methodDefinitions = buildMethodDefinitions({ [name]: [method] }, pathParams);
       ops = [...ops, ...methodDefinitions];
     }
   }

package/src/rlc-common/helpers/typeUtil.ts

@@ -71,12 +71,10 @@ export enum TypeScriptType {
   object,
   union,
   unknown,
-  enum
+  enum,
 }
 
-export function toTypeScriptTypeFromSchema(
-  schema: Schema
-): TypeScriptType | undefined {
+export function toTypeScriptTypeFromSchema(schema: Schema): TypeScriptType | undefined {
   schema.type = schema.type.trim();
   if (
     schema.type === "string" &&
@@ -92,10 +90,7 @@ export function toTypeScriptTypeFromSchema(
       // Include both extensible and fixed enum
       return TypeScriptType.enum;
     }
-  } else if (
-    schema.isConstant === true ||
-    isConstant(schema.typeName ?? schema.type)
-  ) {
+  } else if (schema.isConstant === true || isConstant(schema.typeName ?? schema.type)) {
     return TypeScriptType.constant;
   } else if (schema.type === "number") {
     return TypeScriptType.number;
@@ -115,9 +110,7 @@ export function toTypeScriptTypeFromSchema(
   return undefined;
 }
 
-export function toTypeScriptTypeFromName(
-  typeName: string
-): TypeScriptType | undefined {
+export function toTypeScriptTypeFromName(typeName: string): TypeScriptType | undefined {
   typeName = typeName.trim();
   if (typeName === "Date") {
     return TypeScriptType.date;

package/src/rlc-common/helpers/valueGenerationUtil.ts

@@ -7,7 +7,7 @@ import {
   DictionarySchema,
   ObjectSchema,
   Schema,
-  SchemaContext
+  SchemaContext,
 } from "../interfaces.js";
 import {
   TypeScriptType,
@@ -20,7 +20,7 @@ import {
   leaveBracket,
   leaveStringQuotes,
   toTypeScriptTypeFromName,
-  toTypeScriptTypeFromSchema
+  toTypeScriptTypeFromSchema,
 } from "./typeUtil.js";
 
 /**
@@ -37,7 +37,7 @@ export function generateParameterTypeValue(
   parameterName: string,
   schemaMap: Map<string, Schema>,
   path: Set<string> = new Set(),
-  _allowMockValue = true
+  _allowMockValue = true,
 ): string | undefined {
   type = leaveBracket(type?.trim());
   let tsType: TypeScriptType | undefined;
@@ -85,25 +85,20 @@ function mockEnumValues(
   type: string,
   parameterName: string,
   schemaMap: Map<string, Schema>,
-  path: Set<string> = new Set()
+  path: Set<string> = new Set(),
 ) {
   const schema = schemaMap.get(type);
   if (schema && schema.enum && schema.enum.length > 0) {
     return schema.enum[0].type;
   }
-  return generateParameterTypeValue(
-    getUnionType(type),
-    parameterName,
-    schemaMap,
-    path
-  );
+  return generateParameterTypeValue(getUnionType(type), parameterName, schemaMap, path);
 }
 
 function mockUnionValues(
   type: string,
   parameterName: string,
   schemaMap: Map<string, Schema>,
-  path: Set<string> = new Set()
+  path: Set<string> = new Set(),
 ) {
   const schema = schemaMap.get(type);
   if (schema && schema.enum && schema.enum.length > 0) {
@@ -112,22 +107,17 @@ function mockUnionValues(
       getAccurateTypeName(schema.enum[0]) ?? schema.enum[0],
       parameterName,
       schemaMap,
-      path
+      path,
     );
   }
-  return generateParameterTypeValue(
-    getUnionType(type),
-    parameterName,
-    schemaMap,
-    path
-  );
+  return generateParameterTypeValue(getUnionType(type), parameterName, schemaMap, path);
 }
 
 function generateRecordValues(
   type: string,
   parameterName: string,
   schemaMap: Map<string, Schema>,
-  path: Set<string> = new Set()
+  path: Set<string> = new Set(),
 ) {
   let recordType = getRecordType(type);
   const schema = schemaMap.get(type) as DictionarySchema;
@@ -137,12 +127,7 @@ function generateRecordValues(
   }
 
   return recordType
-    ? `{"key": ${generateParameterTypeValue(
-        recordType,
-        parameterName,
-        schemaMap,
-        path
-      )}}`
+    ? `{"key": ${generateParameterTypeValue(recordType, parameterName, schemaMap, path)}}`
     : `{}`;
 }
 
@@ -150,7 +135,7 @@ function generateArrayValues(
   type: string,
   parameterName: string,
   schemaMap: Map<string, Schema>,
-  path: Set<string> = new Set()
+  path: Set<string> = new Set(),
 ) {
   let arrayType;
   const schema = schemaMap.get(type) as ArraySchema;
@@ -172,7 +157,7 @@ function generateObjectValues(
   type: string,
   _parameterName: string,
   schemaMap: Map<string, Schema>,
-  path: Set<string> = new Set()
+  path: Set<string> = new Set(),
 ) {
   if (path.has(type)) {
     // skip generating if self referenced
@@ -189,7 +174,7 @@ function generateObjectValues(
 
 function getAllProperties(
   schema?: ObjectSchema,
-  schemaMap: Map<string, Schema> = new Map()
+  schemaMap: Map<string, Schema> = new Map(),
 ): Map<string, Schema> {
   const propertiesMap: Map<string, Schema> = new Map();
   if (!schema) {
@@ -213,7 +198,7 @@ function getAllProperties(
 function extractObjectProperties(
   properties: Map<string, Schema>,
   schemaMap: Map<string, Schema> = new Map(),
-  path: Set<string> = new Set()
+  path: Set<string> = new Set(),
 ) {
   const values: string[] = [];
   for (const name of properties.keys()) {
@@ -224,12 +209,7 @@ function extractObjectProperties(
     addToSchemaMap(schemaMap, property);
     values.push(
       `${name}: ` +
-        generateParameterTypeValue(
-          getAccurateTypeName(property),
-          name,
-          schemaMap,
-          path
-        )
+        generateParameterTypeValue(getAccurateTypeName(property), name, schemaMap, path),
     );
   }
   return values;
@@ -248,10 +228,7 @@ function addToSchemaMap(schemaMap: Map<string, Schema>, schema: Schema) {
   if (!type) {
     return;
   }
-  if (
-    !schemaMap.has(type) &&
-    !["string", "number", "boolean"].includes(schema.type)
-  ) {
+  if (!schemaMap.has(type) && !["string", "number", "boolean"].includes(schema.type)) {
     schemaMap.set(type, schema);
   }
 }