@azure-tools/typespec-ts 0.17.1 → 0.18.0

package/src/utils/modelUtils.ts

@@ -47,6 +47,7 @@ import {
 } from "@typespec/compiler";
 import { reportDiagnostic } from "../lib.js";
 import {
+  ArraySchema,
   DictionarySchema,
   NameType,
   normalizeName,
@@ -82,7 +83,10 @@ export function isByteOrByteUnion(dpgContext: SdkContext, type: Type) {
 }
 
 function isByteType(schema: any) {
-  return schema.type === "string" && schema.format === "byte";
+  return (
+    schema.type === "string" &&
+    (schema.format === "byte" || schema.format === "binary")
+  );
 }
 
 function isByteUnion(schema: any) {
@@ -147,20 +151,36 @@ export function getSchemaForType(
   }
   if (type.kind === "Model") {
     const schema = getSchemaForModel(dpgContext, type, usage, needRef) as any;
-    if (!isArrayModelType(program, type) && !isRecordModelType(program, type)) {
-      if (usage && usage.includes(SchemaContext.Output)) {
-        if (!schema.name || schema.name === "") {
-          //TODO: HANDLE ANONYMOUS
+    if (isAnonymousObjectSchema(schema)) {
+      if (Object.keys(schema.properties ?? {}).length === 0) {
+        // Handle empty anonymous model as Record
+        schema.typeName =
+          schema.type === "object" ? "Record<string, unknown>" : "unknown";
+        if (usage && usage.includes(SchemaContext.Output)) {
           schema.outputTypeName =
             schema.type === "object" ? "Record<string, any>" : "any";
-          schema.typeName =
-            schema.type === "object" ? "Record<string, unknown>" : "unknown";
-          schema.type = "unknown";
-        } else {
-          schema.outputTypeName = `${schema.name}Output`;
-          schema.typeName = `${schema.name}`;
         }
+        schema.type = "unknown";
+      } else {
+        // Handle non-empty anonymous model as inline model
+        if (usage && usage.includes(SchemaContext.Output)) {
+          schema.outputTypeName = getModelInlineSigniture(schema, {
+            usage: [SchemaContext.Output]
+          });
+        }
+        schema.typeName = getModelInlineSigniture(schema, {
+          usage: [SchemaContext.Input]
+        });
+        schema.type = "object";
+      }
+    } else if (
+      !isArrayModelType(program, type) &&
+      !isRecordModelType(program, type)
+    ) {
+      if (usage && usage.includes(SchemaContext.Output)) {
+        schema.outputTypeName = `${schema.name}Output`;
       }
+      schema.typeName = `${schema.name}`;
     }
     schema.usage = usage;
     return schema;
@@ -222,20 +242,74 @@ export function includeDerivedModel(model: Model): boolean {
   );
 }
 
+function applyEncoding(
+  dpgContext: SdkContext,
+  typespecType: Scalar | ModelProperty,
+  target: any = {}
+) {
+  const encodeData = getEncode(dpgContext.program, typespecType);
+  if (encodeData) {
+    const newTarget = { ...target };
+    const newType = getSchemaForScalar(dpgContext, encodeData.type);
+    newTarget["type"] = newType["type"];
+    newTarget["typeName"] = newType["typeName"];
+    newTarget["outputTypeName"] = newType["outputTypeName"];
+    // If the target already has a format it takes priority. (e.g. int32)
+    newTarget["format"] = mergeFormatAndEncoding(
+      newTarget.format,
+      encodeData.encoding,
+      newType["format"]
+    );
+    return newTarget;
+  }
+  return target;
+}
+
+function mergeFormatAndEncoding(
+  format: string | undefined,
+  encoding: string,
+  encodeAsFormat: string | undefined
+): string {
+  switch (format) {
+    case undefined:
+      return encodeAsFormat ?? encoding;
+    case "date-time":
+      return encoding;
+    case "duration":
+    default:
+      return encodeAsFormat ?? encoding;
+  }
+}
+
 function getSchemaForScalar(
   dpgContext: SdkContext,
   scalar: Scalar,
   relevantProperty?: ModelProperty
 ) {
-  const program = dpgContext.program;
-  const encodeData = getEncode(program, scalar);
-  let result: any = encodeData
-    ? getSchemaForScalar(dpgContext, encodeData.type)
-    : getSchemaForStdScalar(program, scalar, relevantProperty);
-  if (!result && scalar.baseScalar) {
+  let result = {};
+  const isStd = dpgContext.program.checker.isStdType(scalar);
+  if (isStd) {
+    result = getSchemaForStdScalar(
+      dpgContext.program,
+      scalar,
+      relevantProperty
+    );
+  } else if (scalar.baseScalar) {
     result = getSchemaForScalar(dpgContext, scalar.baseScalar);
   }
-  return applyIntrinsicDecorators(program, scalar, result);
+  const withDecorators = applyEncoding(
+    dpgContext,
+    scalar,
+    result
+      ? applyIntrinsicDecorators(dpgContext.program, scalar, result)
+      : undefined
+  );
+  if (withDecorators.type === "string" && withDecorators.format === "binary") {
+    withDecorators.typeName =
+      "string | Uint8Array | ReadableStream<Uint8Array> | NodeJS.ReadableStream";
+    withDecorators.outputTypeName = "Uint8Array";
+  }
+  return withDecorators;
 }
 
 function getSchemaForUnion(
@@ -523,7 +597,7 @@ function getSchemaForModel(
           dpgContext,
           prop.type,
           usage,
-          true,
+          !isAnonymousModelType(prop.type),
           prop
         );
         childSchema.discriminatorValue = propSchema.type.replace(/"/g, "");
@@ -578,9 +652,10 @@ function getSchemaForModel(
       dpgContext,
       prop.type,
       usage,
-      true,
+      isAnonymousModelType(prop.type) ? false : true,
       prop
     );
+
     if (propSchema === undefined) {
       continue;
     }
@@ -605,12 +680,7 @@ function getSchemaForModel(
     }
 
     // Apply decorators on the property to the type's schema
-    const newPropSchema = applyIntrinsicDecorators(
-      program,
-
-      prop,
-      propSchema
-    );
+    const newPropSchema = applyIntrinsicDecorators(program, prop, propSchema);
     if (newPropSchema === undefined) {
       continue;
     }
@@ -677,7 +747,7 @@ function applyIntrinsicDecorators(
   const isString = isStringType(program, getPropertyType(type));
   const isNumeric = isNumericType(program, getPropertyType(type));
 
-  if (isString && !target.documentation && docStr) {
+  if (isString && !target?.documentation && docStr) {
     newTarget.description = docStr;
   }
 
@@ -785,7 +855,12 @@ function getSchemaForArrayModel(
   if (isArrayModelType(program, type)) {
     schema = {
       type: "array",
-      items: getSchemaForType(dpgContext, indexer.value!, usage, true),
+      items: getSchemaForType(
+        dpgContext,
+        indexer.value!,
+        usage,
+        !isAnonymousModelType(indexer.value!)
+      ),
       description: getDoc(program, type)
     };
     if (
@@ -805,6 +880,19 @@ function getSchemaForArrayModel(
           schema.typeName = `${schema.items.typeName}[]`;
         } else if (schema.items.type === "union") {
           schema.typeName = `(${schema.items.typeName})[]`;
+        } else if (
+          schema.items.format === "binary" &&
+          schema.items.type === "string"
+        ) {
+          schema.typeName = `Array<${schema.items.typeName}>`;
+          if (usage && usage.includes(SchemaContext.Output)) {
+            schema.outputTypeName = `Array<${schema.items.outputTypeName}>`;
+          }
+        } else if (isAnonymousObjectSchema(schema.items)) {
+          schema.typeName = `${schema.items.typeName}[]`;
+          if (usage && usage.includes(SchemaContext.Output)) {
+            schema.outputTypeName = `${schema.items.outputTypeName}[]`;
+          }
         } else {
           schema.typeName = schema.items.typeName
             .split("|")
@@ -848,7 +936,12 @@ function getSchemaForRecordModel(
     return schema;
   }
   if (isRecordModelType(program, type)) {
-    const valueType = getSchemaForType(dpgContext, indexer?.value, usage, true);
+    const valueType = getSchemaForType(
+      dpgContext,
+      indexer?.value,
+      usage,
+      !isAnonymousModelType(indexer.value)
+    );
     schema = {
       type: "dictionary",
       additionalProperties: valueType,
@@ -983,6 +1076,16 @@ function getSchemaForStdScalar(
         format: "float"
       });
     case "string":
+      if (format === "binary") {
+        return {
+          type: "string",
+          format: "binary",
+          description,
+          typeName:
+            "string | Uint8Array | ReadableStream<Uint8Array> | NodeJS.ReadableStream",
+          outputTypeName: "Uint8Array"
+        };
+      }
       return applyIntrinsicDecorators(program, type, {
         type: "string"
       });
@@ -1022,6 +1125,8 @@ function getSchemaForStdScalar(
       };
     case "duration":
       return { type: "string", format, description };
+    case "url":
+      return { type: "string", format: "uri" };
   }
 }
 
@@ -1052,24 +1157,60 @@ export function getTypeName(schema: Schema, usage?: SchemaContext[]): string {
   return getPriorityName(schema, usage) ?? schema.type ?? "any";
 }
 
-export function getImportedModelName(schema: Schema): string[] | undefined {
+export function getImportedModelName(
+  schema: Schema,
+  usage?: SchemaContext[]
+): string[] {
   switch (schema.type) {
-    case "array":
-      return [(schema as any).items]
-        .filter((i: Schema) => i.type === "object")
-        .map((i: Schema) => getPriorityName(i) ?? "");
-    case "object":
-      return getPriorityName(schema) ? [getPriorityName(schema)] : undefined;
+    case "array": {
+      const ret = new Set<string>();
+      [(schema as ArraySchema).items]
+        .filter((i?: Schema) => !!i && i.type === "object")
+        .forEach((i?: Schema) =>
+          getImportedModelName(i!, usage).forEach((it) => ret.add(it))
+        );
+      return [...ret];
+    }
+    case "object": {
+      if (isAnonymousObjectSchema(schema)) {
+        const ret = new Set<string>();
+        const properties = (schema as ObjectSchema).properties ?? {};
+        for (const name in properties) {
+          if (!properties[name]) {
+            continue;
+          }
+          getImportedModelName(properties[name]!, usage).forEach((it) =>
+            ret.add(it)
+          );
+        }
+        return [...ret];
+      }
+      return getPriorityName(schema, usage)
+        ? [getPriorityName(schema, usage)]
+        : [];
+    }
     case "dictionary": {
-      const importName = getDictionaryValueName(schema as DictionarySchema);
-      return importName ? [importName] : undefined;
+      const ret = new Set<string>();
+      [(schema as DictionarySchema).additionalProperties]
+        .filter((i?: Schema) => !!i && i.type === "object")
+        .forEach((i?: Schema) =>
+          getImportedModelName(i!, usage).forEach((it) => ret.add(it))
+        );
+
+      return [...ret];
+    }
+    case "union": {
+      const ret = new Set<string>();
+      ((schema as Schema).enum ?? [])
+        .filter((i?: Schema) => !!i && i.type === "object")
+        .forEach((i?: Schema) =>
+          getImportedModelName(i!, usage).forEach((it) => ret.add(it))
+        );
+
+      return [...ret];
     }
-    case "union":
-      return (schema as any).enum
-        .filter((i: Schema) => i.type === "object")
-        .map((i: Schema) => getPriorityName(i) ?? "");
     default:
-      return;
+      return [];
   }
 }
 
@@ -1080,9 +1221,7 @@ function getPriorityName(schema: Schema, usage?: SchemaContext[]): string {
     ? schema.typeName ?? schema.name
     : schema.outputTypeName ?? schema.typeName ?? schema.name;
 }
-function getDictionaryValueName(schema: DictionarySchema): string | undefined {
-  return schema.outputValueTypeName ?? schema.valueTypeName ?? undefined;
-}
+
 function getEnumStringDescription(type: any) {
   if (type.name === "string" && type.enum && type.enum.length > 0) {
     return `Possible values: ${type.enum.join(", ")}`;
@@ -1271,3 +1410,50 @@ export function isAzureCoreErrorType(t?: Type): boolean {
   }
   return namespaces.length == 0;
 }
+
+// Check if the schema is an anonymous object
+export function isAnonymousObjectSchema(schema: Schema) {
+  return schema.name === "" && schema.type === "object";
+}
+
+// Check if the type is an anonymous model
+export function isAnonymousModelType(type: Type) {
+  if (type.kind === "Model") {
+    return type.name === "";
+  }
+  return false;
+}
+
+/**
+ * Get the inline signiture of the model
+ * @param schema object schema detail
+ * @param options other optional parameters
+ * @returns
+ */
+export function getModelInlineSigniture(
+  schema: ObjectSchema,
+  options: { importedModels?: Set<string>; usage?: SchemaContext[] } = {}
+) {
+  let schemaSigiture = `{`;
+  for (const propName in schema.properties) {
+    const propType = schema.properties[propName]!;
+    const propTypeName = getTypeName(propType, options.usage);
+    if (!propType || !propTypeName) {
+      continue;
+    }
+    if (options.importedModels) {
+      const importNames = getImportedModelName(propType);
+      if (importNames) {
+        importNames!.forEach(
+          options.importedModels.add,
+          options.importedModels
+        );
+      }
+    }
+    const isOptional = propType.required ? "" : "?";
+    schemaSigiture += `${propName}${isOptional}: ${propTypeName};`;
+  }
+
+  schemaSigiture += `}`;
+  return schemaSigiture;
+}

package/src/utils/operationUtil.ts

@@ -7,6 +7,7 @@ import {
   ResponseMetadata,
   ResponseTypes,
   getLroLogicalResponseName,
+  getResponseTypeName,
   normalizeName
 } from "@azure-tools/rlc-common";
 import {
@@ -23,7 +24,7 @@ import {
   HttpOperation,
   HttpOperationParameter,
   HttpOperationResponse,
-  StatusCode,
+  HttpStatusCodesEntry,
   getHttpOperation
 } from "@typespec/http";
 import {
@@ -44,14 +45,85 @@ import {
 import { isByteOrByteUnion } from "./modelUtils.js";
 import { SdkContext } from "./interfaces.js";
 
+// Sorts the responses by status code
+export function sortedOperationResponses(responses: HttpOperationResponse[]) {
+  return responses.sort((a, b) => {
+    if (a.statusCodes === "*") {
+      return 1;
+    }
+    if (b.statusCodes === "*") {
+      return -1;
+    }
+    const aStatus =
+      typeof a.statusCodes === "number" ? a.statusCodes : a.statusCodes.start;
+    const bStatus =
+      typeof b.statusCodes === "number" ? b.statusCodes : b.statusCodes.start;
+    return aStatus - bStatus;
+  });
+}
+
+/**
+ * This function computes all the response types error and success
+ * an operation can end up returning.
+ */
+export function getOperationResponseTypes(
+  dpgContext: SdkContext,
+  operation: HttpOperation
+): ResponseTypes {
+  const returnTypes: ResponseTypes = {
+    error: [],
+    success: []
+  };
+  function getResponseType(responses: HttpOperationResponse[]) {
+    return responses.map((r) => {
+      const statusCode = getOperationStatuscode(r);
+      const responseName = getResponseTypeName(
+        getOperationGroupName(dpgContext, operation),
+        getOperationName(dpgContext.program, operation.operation),
+        statusCode
+      );
+      return responseName;
+    });
+  }
+  if (operation.responses && operation.responses.length) {
+    returnTypes.error = getResponseType(
+      operation.responses.filter((r) => isDefaultStatusCode(r.statusCodes))
+    );
+    returnTypes.success = getResponseType(
+      operation.responses.filter((r) => isDefinedStatusCode(r.statusCodes))
+    );
+  }
+  return returnTypes;
+}
+
+/**
+ * Extracts all success or defined status codes for a give operation
+ */
+export function getOperationSuccessStatus(operation: HttpOperation): string[] {
+  const responses = operation.responses ?? [];
+  const status: string[] = [];
+
+  for (const response of responses) {
+    if (isDefinedStatusCode(response.statusCodes)) {
+      status.push(getOperationStatuscode(response));
+    }
+  }
+
+  return status;
+}
+
 export function getOperationStatuscode(
   response: HttpOperationResponse
 ): string {
-  switch (response.statusCode) {
-    case "*":
-      return "default";
-    default:
-      return `${response.statusCode}`;
+  const statusCodes = response.statusCodes;
+  if (statusCodes === "*") {
+    return "default";
+  } else if (typeof statusCodes === "number") {
+    return String(statusCodes);
+  } else {
+    // FIXME - this is a hack to get the first status code
+    // https://github.com/Azure/autorest.typescript/issues/2063
+    return String(statusCodes.start);
   }
 }
 
@@ -105,12 +177,12 @@ export function getOperationName(program: Program, operation: Operation) {
   );
 }
 
-export function isDefaultStatusCode(statusCode: StatusCode) {
-  return statusCode === "*";
+export function isDefaultStatusCode(statusCodes: HttpStatusCodesEntry) {
+  return statusCodes === "*";
 }
 
-export function isDefinedStatusCode(statusCode: StatusCode) {
-  return statusCode !== "*";
+export function isDefinedStatusCode(statusCodes: HttpStatusCodesEntry) {
+  return statusCodes !== "*";
 }
 
 export function isBinaryPayload(