@azure-tools/typespec-ts 0.34.0 → 0.35.0-alpha.20241203.1

package/src/transform/transfromRLCOptions.ts

@@ -317,10 +317,12 @@ function getServiceInfo(program: Program): ServiceInfo {
 }
 
 function getAzureSdkForJs(emitterOptions: EmitterOptions) {
-  return emitterOptions.azureSdkForJs === undefined ||
-    emitterOptions.azureSdkForJs === null
-    ? true
-    : Boolean(emitterOptions.azureSdkForJs);
+  return emitterOptions.flavor !== "azure"
+    ? false
+    : emitterOptions.azureSdkForJs === undefined ||
+        emitterOptions.azureSdkForJs === null
+      ? true
+      : Boolean(emitterOptions.azureSdkForJs);
 }
 
 function getGenerateMetadata(emitterOptions: EmitterOptions) {

package/src/utils/emitUtil.ts

@@ -54,6 +54,9 @@ async function emitFile(
   isAzureFlavor: boolean,
   emitterOutputDir?: string
 ) {
+  if (program.compilerOptions.noEmit || program.hasError()) {
+    return;
+  }
   const host: CompilerHost = program.host;
   const filePath = join(emitterOutputDir ?? "", file.path);
   const isJson = /\.json$/gi.test(filePath);

package/src/utils/modelUtils.ts

@@ -1132,6 +1132,18 @@ function isUnionType(type: Type) {
   return type.kind === "Union";
 }
 
+export function isObjectOrDictType(schema: Schema) {
+  return (
+    (schema.type === "object" &&
+      (schema as ObjectSchema).properties !== undefined) ||
+    schema.type === "dictionary"
+  );
+}
+
+export function isArrayType(schema: Schema) {
+  return schema.type === "array";
+}
+
 function getSchemaForStdScalar(
   program: Program,
   type: Scalar,
@@ -1331,38 +1343,6 @@ export function getTypeName(schema: Schema, usage?: SchemaContext[]): string {
   return getPriorityName(schema, usage) ?? schema.type ?? "any";
 }
 
-export function getSerializeTypeName(
-  program: Program,
-  schema: Schema,
-  usage?: SchemaContext[]
-): string {
-  const typeName = getTypeName(schema, usage);
-  const formattedName = (schema.alias ?? typeName).replace(
-    "Date | string",
-    "string"
-  );
-  const canSerialize = isSerializable(schema);
-  if (canSerialize) {
-    return schema.alias ? typeName : formattedName;
-  }
-  reportDiagnostic(program, {
-    code: "unable-serialized-type",
-    format: { type: typeName },
-    target: NoTarget
-  });
-  return "string";
-  function isSerializable(type: any) {
-    if (type.enum) {
-      return type.enum.every((i: any) => {
-        return isSerializable(i) || i.type === "null";
-      });
-    }
-    return (
-      ["string", "number", "boolean"].includes(type.type) || type.isConstant
-    );
-  }
-}
-
 export function getImportedModelName(
   schema: Schema,
   usage?: SchemaContext[]
@@ -1448,7 +1428,7 @@ function getEnumStringDescription(type: any) {
   return undefined;
 }
 
-function getBinaryDescripton(type: any) {
+function getBinaryDescription(type: any) {
   if (type?.typeName?.includes(BINARY_TYPE_UNION)) {
     return `Value may contain any sequence of octets`;
   }
@@ -1480,7 +1460,7 @@ export function getFormattedPropertyDoc(
   const enhancedDocFromType =
     getEnumStringDescription(schemaType) ??
     getDecimalDescription(schemaType) ??
-    getBinaryDescripton(schemaType);
+    getBinaryDescription(schemaType);
   if (propertyDoc && enhancedDocFromType) {
     return `${propertyDoc}${sperator}${enhancedDocFromType}`;
   }

package/src/utils/operationUtil.ts

@@ -409,13 +409,16 @@ export function extractPagedMetadataNested(
 }
 
 export function getSpecialSerializeInfo(
+  dpgContext: SdkContext,
   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 hasMultiCollection = getHasMultiCollection(
+    paramType,
+    paramFormat,
+    // Include query multi support in compatibility mode
+    dpgContext.rlcOptions?.compatibilityQueryMultiFormat ?? false
+  );
   const hasCsvCollection = getHasCsvCollection(paramType, paramFormat);
   const descriptions = [];
   const collectionInfo = [];
@@ -423,20 +426,6 @@ export function getSpecialSerializeInfo(
     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");
@@ -444,18 +433,20 @@ export function getSpecialSerializeInfo(
   }
   return {
     hasMultiCollection,
-    hasPipeCollection,
-    hasSsvCollection,
-    hasTsvCollection,
     hasCsvCollection,
     descriptions,
     collectionInfo
   };
 }
 
-function getHasMultiCollection(paramType: string, paramFormat: string) {
+function getHasMultiCollection(
+  paramType: string,
+  paramFormat: string,
+  includeQuery = true
+) {
   return (
-    (paramType === "query" || paramType === "header") && paramFormat === "multi"
+    ((includeQuery && paramType === "query") || paramType === "header") &&
+    paramFormat === "multi"
   );
 }
 function getHasSsvCollection(paramType: string, paramFormat: string) {

package/src/utils/parameterUtils.ts

@@ -0,0 +1,234 @@
+import {
+  NameType,
+  normalizeName,
+  Schema,
+  SchemaContext
+} from "@azure-tools/rlc-common";
+import { HttpOperationParameter } from "@typespec/http";
+import { getTypeName, isArrayType, isObjectOrDictType } from "./modelUtils.js";
+import { SdkContext } from "./interfaces.js";
+import { reportDiagnostic } from "../lib.js";
+import { NoTarget, Program } from "@typespec/compiler";
+
+export interface ParameterSerializationInfo {
+  typeName: string;
+  wrapperType?: Schema;
+}
+
+export function getParameterSerializationInfo(
+  dpgContext: SdkContext,
+  parameter: HttpOperationParameter,
+  valueSchema: Schema,
+  operationGroup: string = "",
+  operationName: string = ""
+): ParameterSerializationInfo {
+  const schemaContext = [SchemaContext.Input];
+  const retVal: ParameterSerializationInfo = buildSerializationInfo(
+    getTypeName(valueSchema, schemaContext)
+  );
+  const prefix = `${operationGroup}_${operationName}_${parameter.name}`;
+  switch (parameter.type) {
+    case "path": {
+      if (parameter.allowReserved === true) {
+        const wrapperType = buildAllowReserved(
+          normalizeName(`${prefix}_PathParam`, NameType.Interface),
+          valueSchema,
+          parameter.name
+        );
+        return buildSerializationInfo(wrapperType);
+      }
+      return retVal;
+    }
+    case "query": {
+      if (!isArrayType(valueSchema) && !isObjectOrDictType(valueSchema)) {
+        // if the value is a primitive type or other types, we will not generate a wrapper type
+        return retVal;
+      }
+      const name = normalizeName(`${prefix}_QueryParam`, NameType.Interface);
+      if (parameter.explode === true) {
+        if (parameter.format !== undefined && parameter.format !== "multi") {
+          reportDiagnostic(dpgContext.program, {
+            code: "un-supported-format-cases",
+            format: {
+              paramName: parameter.name,
+              explode: String(parameter.explode),
+              format: parameter.format
+            },
+            target: NoTarget
+          });
+        }
+        let wrapperType: Schema = buildExplodeAndStyle(
+          name,
+          true,
+          "form",
+          valueSchema,
+          parameter.name
+        );
+        if (dpgContext.rlcOptions?.compatibilityQueryMultiFormat) {
+          wrapperType = buildUnionType([
+            wrapperType,
+            { type: "string", name: "string" }
+          ]);
+        }
+        return buildSerializationInfo(wrapperType);
+      }
+
+      if (parameter.format === undefined || parameter.format === "csv") {
+        let wrapperType: Schema = buildExplodeAndStyle(
+          name,
+          false,
+          "form",
+          valueSchema,
+          parameter.name
+        );
+        if (isArrayType(valueSchema)) {
+          wrapperType = buildUnionType([valueSchema, wrapperType]);
+        }
+        return buildSerializationInfo(wrapperType);
+      } else if (parameter.format === "ssv" || parameter.format === "pipes") {
+        const wrapperType = buildExplodeAndStyle(
+          name,
+          false,
+          parameter.format === "ssv" ? "spaceDelimited" : "pipeDelimited",
+          valueSchema,
+          parameter.name
+        );
+        return buildSerializationInfo(wrapperType);
+      } else {
+        reportDiagnostic(dpgContext.program, {
+          code: "un-supported-format-cases",
+          format: {
+            paramName: parameter.name,
+            explode: String(parameter.explode),
+            format: parameter.format
+          },
+          target: NoTarget
+        });
+      }
+      return buildSerializationInfo("string");
+    }
+    case "header": {
+      return buildSerializationInfo(
+        getHeaderSerializeTypeName(
+          dpgContext.program,
+          valueSchema,
+          schemaContext
+        )
+      );
+    }
+    default:
+      return retVal;
+  }
+}
+
+function buildSerializationInfo(
+  typeOrSchema: string | Schema
+): ParameterSerializationInfo {
+  if (typeof typeOrSchema === "string") {
+    return {
+      typeName: typeOrSchema
+    };
+  }
+  return {
+    typeName: getTypeName(typeOrSchema),
+    wrapperType: typeOrSchema
+  };
+}
+
+function getHeaderSerializeTypeName(
+  program: Program,
+  schema: Schema,
+  usage?: SchemaContext[]
+): string {
+  const typeName = getTypeName(schema, usage);
+  const formattedName = (schema.alias ?? typeName).replace(
+    "Date | string",
+    "string"
+  );
+  const canSerialize = isSerializable(schema);
+  if (canSerialize) {
+    return schema.alias ? typeName : formattedName;
+  }
+  reportDiagnostic(program, {
+    code: "unable-serialized-type",
+    format: { type: typeName },
+    target: NoTarget
+  });
+  return "string";
+  function isSerializable(type: any) {
+    if (type.enum) {
+      return type.enum.every((i: any) => {
+        return isSerializable(i) || i.type === "null";
+      });
+    }
+    return (
+      ["string", "number", "boolean"].includes(type.type) || type.isConstant
+    );
+  }
+}
+
+function buildAllowReserved(
+  typeName: string,
+  valueSchema: Schema,
+  parameterName: string
+) {
+  return {
+    type: "object",
+    name: typeName,
+    description: `This is the wrapper object for the parameter \`${parameterName}\` with allowReserved set to true.`,
+    properties: {
+      value: {
+        ...valueSchema,
+        description: valueSchema.description ?? "Value of the parameter",
+        required: true
+      },
+      allowReserved: {
+        type: `true`,
+        description: "Whether to allow reserved characters",
+        required: true
+      }
+    }
+  };
+}
+
+function buildExplodeAndStyle(
+  typeName: string,
+  explode: boolean,
+  style: string,
+  valueSchema: Schema,
+  parameterName: string
+) {
+  return {
+    type: "object",
+    name: typeName,
+    description: `This is the wrapper object for the parameter \`${parameterName}\` with explode set to ${explode} and style set to ${style}.`,
+    properties: {
+      value: {
+        ...valueSchema,
+        description: valueSchema.description ?? "Value of the parameter",
+        required: true
+      },
+      explode: {
+        type: `${explode}`,
+        description: "Should we explode the value?",
+        required: true
+      },
+      style: {
+        type: `"${style}"`,
+        description: "Style of the value",
+        required: true
+      }
+    }
+  };
+}
+
+function buildUnionType(values: Schema[]) {
+  return {
+    name: "",
+    enum: values,
+    type: "union",
+    typeName: `${values.map((v) => getTypeName(v)).join(" | ")}`,
+    required: true,
+    description: undefined
+  };
+}

package/static/static-helpers/pagingHelpers.ts

@@ -1,6 +1,3 @@
-// Copyright (c) Microsoft Corporation.
-// Licensed under the MIT License.
-
 import {
   Client,
   createRestError,

package/static/static-helpers/pollingHelpers.ts

@@ -1,6 +1,3 @@
-// Copyright (c) Microsoft Corporation.
-// Licensed under the MIT License.
-
 import {
   PollerLike,
   OperationState,

package/static/static-helpers/serialization/build-csv-collection.ts

@@ -1,6 +1,3 @@
-// Copyright (c) Microsoft Corporation.
-// Licensed under the MIT License.
-
 export function buildCsvCollection(items: string[] | number[]): string {
   return items.join(",");
 }