@azure-tools/typespec-ts 0.15.0 → 0.16.0-alpha.20230918.1

package/src/utils/modelUtils.ts

@@ -134,7 +134,7 @@ export function getSchemaForType(
   const program = dpgContext.program;
   const type = getEffectiveModelFromType(program, typeInput);
 
-  const builtinType = mapCadlTypeToTypeScript(dpgContext, type, usage);
+  const builtinType = mapTypeSpecTypeToTypeScript(dpgContext, type, usage);
   if (builtinType !== undefined) {
     // add in description elements for types derived from primitive types (SecureString, etc.)
     const doc = getDoc(program, type);
@@ -284,7 +284,7 @@ function getSchemaForUnionVariant(
   return getSchemaForType(dpgContext, variant, usage);
 }
 
-// An openapi "string" can be defined in several different ways in Cadl
+// An openapi "string" can be defined in several different ways in typespec
 function isOasString(type: Type): boolean {
   if (type.kind === "String") {
     // A string literal
@@ -402,7 +402,7 @@ function validateDiscriminator(
  * A "schema property" here is a property that is emitted to OpenAPI schema.
  *
  * Headers, parameters, status codes are not schema properties even they are
- * represented as properties in Cadl.
+ * represented as properties in typespec.
  */
 function isSchemaProperty(program: Program, property: ModelProperty) {
   const headerInfo = getHeaderFieldName(program, property);
@@ -420,9 +420,7 @@ function getSchemaForModel(
 ) {
   const program = dpgContext.program;
   const overridedModelName =
-    getProjectedName(program, model, "javascript") ??
-    getProjectedName(program, model, "client") ??
-    getFriendlyName(program, model);
+    getFriendlyName(program, model) ?? getProjectedName(program, model, "json");
   let name = model.name;
   if (
     !overridedModelName &&
@@ -459,14 +457,7 @@ function getSchemaForModel(
 
   modelSchema.typeName = modelSchema.name;
 
-  if (
-    (model.name === "ErrorResponse" ||
-      model.name === "ErrorModel" ||
-      model.name === "Error") &&
-    model.kind === "Model" &&
-    model.namespace?.name === "Foundations" &&
-    model.namespace.namespace?.name === "Core"
-  ) {
+  if (isAzureCoreErrorType(model)) {
     modelSchema.fromCore = true;
   }
 
@@ -654,86 +645,86 @@ function getSchemaForModel(
   }
   return modelSchema;
 }
-// Map an Cadl type to an OA schema. Returns undefined when the resulting
+// Map an typespec type to an OA schema. Returns undefined when the resulting
 // OA schema is just a regular object schema.
-function mapCadlTypeToTypeScript(
+function mapTypeSpecTypeToTypeScript(
   dpgContext: SdkContext,
-  cadlType: Type,
+  type: Type,
   usage?: SchemaContext[]
 ): any {
-  switch (cadlType.kind) {
+  switch (type.kind) {
     case "Number":
-      return { type: `${cadlType.value}` };
+      return { type: `${type.value}` };
     case "String":
-      return { type: `"${cadlType.value}"` };
+      return { type: `"${type.value}"` };
     case "Boolean":
-      return { type: `${cadlType.value}` };
+      return { type: `${type.value}` };
     case "Model":
-      return mapCadlStdTypeToTypeScript(dpgContext, cadlType, usage);
+      return mapTypeSpecStdTypeToTypeScript(dpgContext, type, usage);
   }
-  if (cadlType.kind === undefined) {
-    if (typeof cadlType === "string") {
-      return { type: `"${cadlType}"` };
-    } else if (typeof cadlType === "number" || typeof cadlType === "boolean") {
-      return { type: `${cadlType}` };
+  if (type.kind === undefined) {
+    if (typeof type === "string") {
+      return { type: `"${type}"` };
+    } else if (typeof type === "number" || typeof type === "boolean") {
+      return { type: `${type}` };
     }
   }
 }
 function applyIntrinsicDecorators(
   program: Program,
-  cadlType: Scalar | ModelProperty,
+  type: Scalar | ModelProperty,
   target: any
 ): any {
   const newTarget = { ...target };
-  const docStr = getDoc(program, cadlType);
-  const isString = isStringType(program, getPropertyType(cadlType));
-  const isNumeric = isNumericType(program, getPropertyType(cadlType));
+  const docStr = getDoc(program, type);
+  const isString = isStringType(program, getPropertyType(type));
+  const isNumeric = isNumericType(program, getPropertyType(type));
 
   if (isString && !target.documentation && docStr) {
     newTarget.description = docStr;
   }
 
-  const restApiName = getProjectedName(program, cadlType, "json");
+  const restApiName = getProjectedName(program, type, "json");
   if (restApiName) {
     newTarget.name = restApiName;
   }
 
-  const summaryStr = getSummary(program, cadlType);
+  const summaryStr = getSummary(program, type);
   if (isString && !target.summary && summaryStr) {
     newTarget.summary = summaryStr;
   }
 
-  const formatStr = getFormat(program, cadlType);
+  const formatStr = getFormat(program, type);
   if (isString && !target.format && formatStr) {
     newTarget.format = formatStr;
   }
 
-  const pattern = getPattern(program, cadlType);
+  const pattern = getPattern(program, type);
   if (isString && !target.pattern && pattern) {
     newTarget.pattern = pattern;
   }
 
-  const minLength = getMinLength(program, cadlType);
+  const minLength = getMinLength(program, type);
   if (isString && !target.minLength && minLength !== undefined) {
     newTarget.minLength = minLength;
   }
 
-  const maxLength = getMaxLength(program, cadlType);
+  const maxLength = getMaxLength(program, type);
   if (isString && !target.maxLength && maxLength !== undefined) {
     newTarget.maxLength = maxLength;
   }
 
-  const minValue = getMinValue(program, cadlType);
+  const minValue = getMinValue(program, type);
   if (isNumeric && !target.minimum && minValue !== undefined) {
     newTarget.minimum = minValue;
   }
 
-  const maxValue = getMaxValue(program, cadlType);
+  const maxValue = getMaxValue(program, type);
   if (isNumeric && !target.maximum && maxValue !== undefined) {
     newTarget.maximum = maxValue;
   }
 
-  if (isSecret(program, cadlType)) {
+  if (isSecret(program, type)) {
     newTarget.format = "password";
     newTarget["x-ms-secret"] = true;
   }
@@ -781,15 +772,15 @@ function enumMemberType(member: EnumMember) {
   return "string";
 }
 /**
- * Map Cadl intrinsic models to open api definitions
+ * Map TypeSpec intrinsic models to open api definitions
  */
-function mapCadlStdTypeToTypeScript(
+function mapTypeSpecStdTypeToTypeScript(
   dpgContext: SdkContext,
-  cadlType: Model,
+  type: Model,
   usage?: SchemaContext[]
 ): any | undefined {
   const program = dpgContext.program;
-  const indexer = (cadlType as Model).indexer;
+  const indexer = (type as Model).indexer;
   if (indexer !== undefined) {
     if (!isNeverType(indexer.key)) {
       const name = indexer.key.name;
@@ -804,7 +795,7 @@ function mapCadlStdTypeToTypeScript(
         schema = {
           type: "dictionary",
           additionalProperties: valueType,
-          description: getDoc(program, cadlType)
+          description: getDoc(program, type)
         };
         if (
           !program.checker.isStdType(indexer.value) &&
@@ -838,7 +829,7 @@ function mapCadlStdTypeToTypeScript(
         schema = {
           type: "array",
           items: getSchemaForType(dpgContext, indexer.value!, usage, true),
-          description: getDoc(program, cadlType)
+          description: getDoc(program, type)
         };
         if (
           !program.checker.isStdType(indexer.value) &&
@@ -897,10 +888,10 @@ function isUnionType(type: Type) {
 
 function getSchemaForStdScalar(
   program: Program,
-  cadlType: Scalar,
+  type: Scalar,
   relevantProperty?: ModelProperty
 ) {
-  if (!program.checker.isStdType(cadlType)) {
+  if (!program.checker.isStdType(type)) {
     return undefined;
   }
 
@@ -909,83 +900,85 @@ function getSchemaForStdScalar(
    *  if absent use typespec type (or default way of serializing that type)
    *  if present respect type provided in @encode
    */
+  let format = undefined;
   if (relevantProperty) {
     const encodeData = getEncode(program, relevantProperty);
-    if (encodeData && isEncodeTypeEffective(cadlType, encodeData)) {
-      cadlType = encodeData.type;
+    if (encodeData && isEncodeTypeEffective(type, encodeData)) {
+      type = encodeData.type;
+      format = encodeData.encoding;
     }
   }
-  const name = cadlType.name;
-  const description = getSummary(program, cadlType);
+  const name = type.name;
+  const description = getSummary(program, type);
   switch (name) {
     case "bytes":
       return { type: "string", format: "byte", description };
     case "integer":
-      return applyIntrinsicDecorators(program, cadlType, {
+      return applyIntrinsicDecorators(program, type, {
         type: "number"
       });
     case "int8":
-      return applyIntrinsicDecorators(program, cadlType, {
+      return applyIntrinsicDecorators(program, type, {
         type: "number",
         format: "int8"
       });
     case "int16":
-      return applyIntrinsicDecorators(program, cadlType, {
+      return applyIntrinsicDecorators(program, type, {
         type: "number",
         format: "int16"
       });
     case "int32":
-      return applyIntrinsicDecorators(program, cadlType, {
+      return applyIntrinsicDecorators(program, type, {
         type: "number",
         format: "int32"
       });
     case "int64":
-      return applyIntrinsicDecorators(program, cadlType, {
+      return applyIntrinsicDecorators(program, type, {
         type: "number",
         format: "int64"
       });
     case "safeint":
-      return applyIntrinsicDecorators(program, cadlType, {
+      return applyIntrinsicDecorators(program, type, {
         type: "number",
         format: "int64"
       });
     case "uint8":
-      return applyIntrinsicDecorators(program, cadlType, {
+      return applyIntrinsicDecorators(program, type, {
         type: "number",
         format: "uint8"
       });
     case "uint16":
-      return applyIntrinsicDecorators(program, cadlType, {
+      return applyIntrinsicDecorators(program, type, {
         type: "number",
         format: "uint16"
       });
     case "uint32":
-      return applyIntrinsicDecorators(program, cadlType, {
+      return applyIntrinsicDecorators(program, type, {
         type: "number",
         format: "uint32"
       });
     case "uint64":
-      return applyIntrinsicDecorators(program, cadlType, {
+      return applyIntrinsicDecorators(program, type, {
         type: "number",
         format: "uint64"
       });
     case "float64":
-      return applyIntrinsicDecorators(program, cadlType, {
+      return applyIntrinsicDecorators(program, type, {
         type: "number",
         format: "double"
       });
     case "float32":
-      return applyIntrinsicDecorators(program, cadlType, {
+      return applyIntrinsicDecorators(program, type, {
         type: "number",
         format: "float"
       });
     case "float":
-      return applyIntrinsicDecorators(program, cadlType, {
+      return applyIntrinsicDecorators(program, type, {
         type: "number",
         format: "float"
       });
     case "string":
-      return applyIntrinsicDecorators(program, cadlType, {
+      return applyIntrinsicDecorators(program, type, {
         type: "string"
       });
     case "boolean":
@@ -993,7 +986,7 @@ function getSchemaForStdScalar(
     case "plainDate":
       return {
         type: "string",
-        format: "date",
+        format,
         description,
         typeName: "Date | string",
         outputTypeName: "string"
@@ -1001,7 +994,7 @@ function getSchemaForStdScalar(
     case "utcDateTime":
       return {
         type: "string",
-        format: "date-time",
+        format,
         description,
         typeName: "Date | string",
         outputTypeName: "string"
@@ -1023,7 +1016,7 @@ function getSchemaForStdScalar(
         outputTypeName: "string"
       };
     case "duration":
-      return { type: "string", format: "duration", description };
+      return { type: "string", format, description };
   }
 }
 
@@ -1094,11 +1087,11 @@ function getEnumStringDescription(type: any) {
 
 export function getFormattedPropertyDoc(
   program: Program,
-  cadlType: ModelProperty | Type,
+  type: ModelProperty | Type,
   schemaType: any,
   sperator: string = "\n\n"
 ) {
-  const propertyDoc = getDoc(program, cadlType);
+  const propertyDoc = getDoc(program, type);
   const enhancedDocFromType = getEnumStringDescription(schemaType);
   if (propertyDoc && enhancedDocFromType) {
     return `${propertyDoc}${sperator}${enhancedDocFromType}`;
@@ -1108,7 +1101,6 @@ export function getFormattedPropertyDoc(
 
 export function getBodyType(
   program: Program,
-
   route: HttpOperation
 ): Type | undefined {
   let bodyModel = route.parameters.bodyType;
@@ -1257,3 +1249,20 @@ export function trimUsage(model: any) {
   }, {});
   return ordered;
 }
+
+export function isAzureCoreErrorType(t?: Type): boolean {
+  if (
+    t?.kind !== "Model" ||
+    !["error", "errorresponse", "innererror"].includes(t.name.toLowerCase())
+  )
+    return false;
+  const namespaces = ".Azure.Core.Foundations".split(".");
+  while (
+    namespaces.length > 0 &&
+    (t?.kind === "Model" || t?.kind === "Namespace") &&
+    t.namespace?.name === namespaces.pop()
+  ) {
+    t = t.namespace;
+  }
+  return namespaces.length == 0;
+}

package/src/utils/operationUtil.ts

@@ -20,10 +20,11 @@ import {
   Type
 } from "@typespec/compiler";
 import {
-  getHttpOperation,
   HttpOperation,
+  HttpOperationParameter,
   HttpOperationResponse,
-  StatusCode
+  StatusCode,
+  getHttpOperation
 } from "@typespec/http";
 import {
   getLroMetadata,
@@ -119,11 +120,11 @@ export function isBinaryPayload(
 ) {
   contentType = `"${contentType}"`;
   if (
-    isByteOrByteUnion(dpgContext, body) &&
     contentType !== `"application/json"` &&
     contentType !== `"text/plain"` &&
     contentType !== `"application/json" | "text/plain"` &&
-    contentType !== `"text/plain" | "application/json"`
+    contentType !== `"text/plain" | "application/json"` &&
+    isByteOrByteUnion(dpgContext, body)
   ) {
     return true;
   }
@@ -350,3 +351,119 @@ export function extractPagedMetadataNested(
   }
   return paged;
 }
+
+export function getSpecialSerializeInfo(
+  paramType: string,
+  paramFormat: string
+) {
+  const hasMultiCollection = getHasMultiCollection(paramType, paramFormat);
+  const hasPipeCollection = getHasPipeCollection(paramType, paramFormat);
+  const hasSsvCollection = getHasSsvCollection(paramType, paramFormat);
+  const hasTsvCollection = getHasTsvCollection(paramType, paramFormat);
+  const hasCsvCollection = getHasCsvCollection(paramType, paramFormat);
+  const descriptions = [];
+  const collectionInfo = [];
+  if (hasMultiCollection) {
+    descriptions.push("buildMultiCollection");
+    collectionInfo.push("multi");
+  }
+  if (hasSsvCollection) {
+    descriptions.push("buildSsvCollection");
+    collectionInfo.push("ssv");
+  }
+
+  if (hasTsvCollection) {
+    descriptions.push("buildTsvCollection");
+    collectionInfo.push("tsv");
+  }
+
+  if (hasPipeCollection) {
+    descriptions.push("buildPipeCollection");
+    collectionInfo.push("pipe");
+  }
+
+  if (hasCsvCollection) {
+    descriptions.push("buildCsvCollection");
+    collectionInfo.push("csv");
+  }
+  return {
+    hasMultiCollection,
+    hasPipeCollection,
+    hasSsvCollection,
+    hasTsvCollection,
+    hasCsvCollection,
+    descriptions,
+    collectionInfo
+  };
+}
+
+function getHasMultiCollection(paramType: string, paramFormat: string) {
+  return (
+    (paramType === "query" || paramType === "header") && paramFormat === "multi"
+  );
+}
+function getHasSsvCollection(paramType: string, paramFormat: string) {
+  return paramType === "query" && paramFormat === "ssv";
+}
+
+function getHasTsvCollection(paramType: string, paramFormat: string) {
+  return paramType === "query" && paramFormat === "tsv";
+}
+
+function getHasCsvCollection(paramType: string, paramFormat: string) {
+  return paramType === "header" && paramFormat === "csv";
+}
+
+function getHasPipeCollection(paramType: string, paramFormat: string) {
+  return paramType === "query" && paramFormat === "pipes";
+}
+
+export function hasCollectionFormatInfo(
+  paramType: string,
+  paramFormat: string
+) {
+  return (
+    getHasMultiCollection(paramType, paramFormat) ||
+    getHasSsvCollection(paramType, paramFormat) ||
+    getHasTsvCollection(paramType, paramFormat) ||
+    getHasCsvCollection(paramType, paramFormat) ||
+    getHasPipeCollection(paramType, paramFormat)
+  );
+}
+
+export function getCollectionFormatHelper(
+  paramType: string,
+  paramFormat: string
+) {
+  const detail = getSpecialSerializeInfo(paramType, paramFormat);
+  return detail.descriptions.length > 0 ? detail.descriptions[0] : undefined;
+}
+
+export function getCustomRequestHeaderNameForOperation(
+  route: HttpOperation
+): string | undefined {
+  const params = route.parameters.parameters.filter(
+    isCustomClientRequestIdParam
+  );
+  if (params.length > 0) {
+    return "client-request-id";
+  }
+
+  return undefined;
+}
+
+export function isCustomClientRequestIdParam(param: HttpOperationParameter) {
+  return (
+    param.type === "header" && param.name.toLowerCase() === "client-request-id"
+  );
+}
+
+export function isIgnoredHeaderParam(param: HttpOperationParameter) {
+  return (
+    isCustomClientRequestIdParam(param) ||
+    (param.type === "header" &&
+      ["return-client-request-id", "ocp-date"].includes(
+        param.name.toLowerCase()
+      ))
+  );
+}