@azure-tools/typespec-ts 0.55.0-dev.1 → 0.55.0-dev.11

package/src/modular/serialization/serialize-utils.ts

@@ -0,0 +1,217 @@
+import {
+  SdkModelPropertyType,
+  SdkModelType,
+  SdkType,
+} from "@azure-tools/typespec-client-generator-core";
+import { getAllAncestors } from "../helpers/operation-helpers.js";
+import { getDirectSubtypes } from "../helpers/type-helpers.js";
+
+/**
+ * Get all discriminated values for a given model type and given discriminator property.
+ * @param type The model type to get discriminated values from.
+ * @param discriminatorProperty The discriminator property to use for filtering.
+ * @returns An array of all discriminated values.
+ */
+export function getAllDiscriminatedValues(
+  type: SdkModelType,
+  discriminatorProperty?: SdkModelPropertyType,
+) {
+  if (!type.discriminatorValue) {
+    return [];
+  }
+  const values: string[] = [];
+  const children = [type];
+  while (children.length > 0) {
+    const model = children.shift()!;
+    // skip if no discriminator value
+    if (!model.discriminatorValue) {
+      continue;
+    }
+    // Check if this model is a subtype of the given discriminator property
+    if (
+      !!discriminatorProperty &&
+      model.baseModel?.discriminatorProperty?.name === discriminatorProperty?.name
+    ) {
+      values.push(model.discriminatorValue);
+      if (model.discriminatorProperty?.name === discriminatorProperty.name) {
+        // Traverse subtypes also if they have the same discriminator property
+        children.push(...getDirectSubtypes(model));
+      }
+    }
+  }
+
+  return values;
+}
+
+export function isSupportedSerializeType(type: SdkType): boolean {
+  return (
+    type.kind === "model" || type.kind === "dict" || type.kind === "array" || type.kind === "union"
+  );
+}
+
+/**
+ *
+ * In general, we have two kinds of basic special union variants.
+ * 1. datetime type
+ * 2. bytes type
+ * If we consider model type, we have the following three type.
+ * 3. model with property of datetime type.
+ * 4. model with property of binary array type.
+ * 5. model that has different property name between rest layer and modular layer.
+ * 6. nested model i.e. model with property that is a model with one of the above three conditions.
+ * If we consider array type, with all the above 6 types as the element types.
+ */
+const specialVariantMap = new WeakMap<SdkType, boolean>();
+export function isSpecialUnionVariant(
+  t: SdkType & { isNonExhaustive?: boolean },
+  variantStack: SdkType[] = [],
+): boolean {
+  if (variantStack.length <= 0) {
+    variantStack.push(t);
+  }
+  const ancestors = getAllAncestors(t);
+  if (specialVariantMap.has(t)) {
+    variantStack.pop();
+    return specialVariantMap.get(t) ?? false;
+  }
+
+  if (
+    t.kind === "utcDateTime" ||
+    t.kind === "plainDate" ||
+    t.kind === "bytes" ||
+    (t.kind === "model" &&
+      t.properties
+        ?.filter((p) => {
+          return !(
+            variantStack.includes(p.type) ||
+            ancestors.includes(p.type) ||
+            (p.type.kind === "array" &&
+              p.type.valueType &&
+              (variantStack.includes(p.type.valueType) || ancestors.includes(p.type.valueType)))
+          );
+        })
+        ?.some(
+          (p) =>
+            (p.kind === "property" && p.name !== p.serializationOptions.json?.name) ||
+            isSpecialUnionVariant(p.type, [...variantStack, p.type]),
+        )) ||
+    isPolymorphicUnion(t) ||
+    (t.kind === "array" &&
+      t.valueType &&
+      !variantStack.includes(t.valueType) &&
+      !ancestors.includes(t.valueType) &&
+      isSpecialUnionVariant(t.valueType, [...variantStack, t.valueType])) ||
+    (t.kind === "union" &&
+      t.variantTypes
+        ?.filter((p) => {
+          return !(variantStack.includes(p) || ancestors.includes(p));
+        })
+        ?.some((p) => {
+          return isSpecialUnionVariant(p, [...variantStack, p]);
+        })) ||
+    (t.kind === "enum" && !(t.isFixed || t.isNonExhaustive))
+  ) {
+    specialVariantMap.set(t, true);
+    variantStack.pop();
+    return true;
+  }
+  variantStack.pop();
+  specialVariantMap.set(t, false);
+  return false;
+}
+
+export function isNormalUnion(t: SdkType): boolean {
+  return (
+    t.kind === "union" &&
+    !(
+      t.variantTypes?.some((p) => {
+        return isSpecialUnionVariant(p);
+      }) ?? false
+    )
+  );
+}
+
+export function isDiscriminatedUnion(
+  type: SdkType,
+): type is SdkModelType & { discriminatorProperty: SdkType } {
+  if (!type) {
+    return false;
+  }
+  return Boolean(
+    type?.kind === "model" && type.discriminatorProperty && type.discriminatedSubtypes,
+  );
+}
+
+export function isSpecialHandledUnion(t: SdkType & { isNonExhaustive?: boolean }): boolean {
+  return isDiscriminatedUnion(t!) || isPolymorphicUnion(t);
+}
+
+const polymorphicUnionMap = new WeakMap<SdkType, boolean>();
+export function isPolymorphicUnion(t: SdkType): boolean {
+  if (polymorphicUnionMap.has(t)) {
+    return polymorphicUnionMap.get(t) ?? false;
+  }
+  const ancestors = getAllAncestors(t);
+  if (
+    t.kind === "model" &&
+    t.discriminatedSubtypes &&
+    Object.values(t.discriminatedSubtypes)
+      ?.filter((p) => {
+        return !ancestors.includes(p);
+      })
+      ?.some((p) => {
+        return isSpecialUnionVariant(p);
+      })
+  ) {
+    polymorphicUnionMap.set(t, true);
+    return true;
+  }
+  polymorphicUnionMap.set(t, false);
+  return false;
+}
+
+export interface ModelSerializeOptions {
+  nameOnly: boolean;
+  skipDiscriminatedUnionSuffix: boolean;
+  // Indicates if the serializer is being built for a property that is flattened.
+  flatten?: {
+    baseModel: SdkModelType;
+    property: SdkModelPropertyType;
+  };
+  // Indicates if any overrides should be applied when building the serializer/deserializer.
+  overrides?: ModelOverrideOptions;
+  // Predefined name to use for the serializer/deserializer instead of generating one.
+  predefinedName?: string;
+}
+
+// Options for overriding model information during serialization/deserialization.
+export interface ModelOverrideOptions {
+  // If true, all properties will be treated as optional during serialization/deserialization.
+  allOptional?: boolean;
+
+  // The <Property, Client_Name> map for any renamed properties.
+  // Mainly because the original client name has collision with other property names during flattening.
+  propertyRenames?: Map<SdkModelPropertyType, string>;
+
+  // If true (default), enable flattening for nested flatten properties when generating samples.
+  // When false, nested flatten properties are not further flattened to match the TypeScript interface structure.
+  enableFlatten?: boolean;
+}
+
+export function getPropertyWithOverrides(
+  property: SdkModelPropertyType,
+  overrides?: ModelOverrideOptions,
+): SdkModelPropertyType {
+  if (!overrides) {
+    return property;
+  }
+  let updatedProperty = property;
+  if (overrides.allOptional) {
+    updatedProperty = { ...updatedProperty, optional: true };
+  }
+  const renamedClientName = overrides.propertyRenames?.get(property);
+  if (renamedClientName) {
+    updatedProperty = { ...updatedProperty, name: renamedClientName };
+  }
+  return updatedProperty;
+}

package/src/modular/type-expressions/get-credential-expression.ts

@@ -1,5 +1,5 @@
 import { SdkCredentialType } from "@azure-tools/typespec-client-generator-core";
-import { useDependencies } from "../../framework/hooks/useDependencies.js";
+import { useDependencies } from "../../framework/hooks/use-dependencies.js";
 import { resolveReference } from "../../framework/reference.js";
 
 export function getCredentialExpression(type: SdkCredentialType): string {

package/src/modular/type-expressions/get-model-expression.ts

@@ -9,7 +9,7 @@ import {
   SdkModelType,
   SdkServiceResponseHeader,
 } from "@azure-tools/typespec-client-generator-core";
-import { useContext } from "../../contextManager.js";
+import { useContext } from "../../context-manager.js";
 import { resolveReference } from "../../framework/reference.js";
 import { refkey } from "../../framework/refkey.js";
 import { SdkContext } from "../../utils/interfaces.js";

package/src/rlc-common/helpers/imports-util.ts

@@ -0,0 +1,172 @@
+import { SourceFile } from "ts-morph";
+import { ImportType, Imports } from "../interfaces.js";
+
+/**
+ * Build the common imports for generated SDK. Azure Core packages are always used.
+ * @returns
+ */
+export function buildRuntimeImports(): Imports {
+  return {
+    restClient: {
+      type: "restClient",
+      specifier: "@azure-rest/core-client",
+      version: "^2.0.0",
+    },
+    coreAuth: {
+      type: "coreAuth",
+      specifier: "@azure/core-auth",
+      version: "^1.6.0",
+    },
+    restPipeline: {
+      type: "restPipeline",
+      specifier: "@azure/core-rest-pipeline",
+      version: "^1.14.0",
+    },
+    coreUtil: {
+      type: "coreUtil",
+      specifier: "@azure/core-util",
+      version: "^1.4.0",
+    },
+    coreLogger: {
+      type: "coreLogger",
+      specifier: "@azure/logger",
+      version: "^1.0.4",
+    },
+    azureEslintPlugin: {
+      type: "azureEslintPlugin",
+      specifier: "@azure/eslint-plugin-azure-sdk",
+      version: "^3.0.0",
+    },
+    azureTestRecorder: {
+      type: "azureTestRecorder",
+      specifier: "@azure-tools/test-recorder",
+      version: "^3.0.0",
+    },
+    azureCoreLro: {
+      type: "azureCoreLro",
+      specifier: "@azure/core-lro",
+    },
+  } as Imports;
+}
+
+/**
+ * Initialize the inner imports for parameter and response, the import set would be used for referred models
+ * @returns
+ */
+export function initInternalImports(): Imports {
+  return {
+    parameter: {
+      type: "parameter",
+      importsSet: new Set<string>(),
+    },
+    response: {
+      type: "response",
+      importsSet: new Set<string>(),
+    },
+    rlcIndex: {
+      type: "rlcIndex",
+      importsSet: new Set<string>(),
+    },
+    modularModel: {
+      type: "modularModel",
+      importsSet: new Set<string>(),
+    },
+    rlcClientFactory: {
+      type: "rlcClientFactory",
+      importsSet: new Set<string>(),
+    },
+    rlcClientDefinition: {
+      type: "rlcClientDefinition",
+      importsSet: new Set<string>(),
+    },
+    serializerHelpers: {
+      type: "serializerHelpers",
+      importsSet: new Set<string>(),
+    },
+  } as Imports;
+}
+
+export function getImportSpecifier(
+  importType: ImportType,
+  imports?: Imports,
+  includeFallback = true,
+): string {
+  imports = imports ?? ({} as Imports);
+  const defaultPackageMap: Record<ImportType, string> = {
+    restClient: "@azure-rest/core-client",
+    coreAuth: "@azure/core-auth",
+    restPipeline: "@azure/core-rest-pipeline",
+    coreUtil: "@azure/core-util",
+    coreLogger: "@azure/logger",
+    azureCoreLro: "@azure/core-lro",
+  } as any;
+  if (!includeFallback) {
+    return imports[importType]?.specifier ?? "";
+  }
+  return (
+    (imports[importType] ?? imports.commonFallback)?.specifier ??
+    defaultPackageMap[importType] ??
+    ""
+  );
+}
+
+export function addImportToSpecifier(
+  importType: ImportType,
+  runtimeImports: Imports,
+  importedName: string,
+): void {
+  const specifier = getImportSpecifier(importType, runtimeImports);
+  const importSet = runtimeImports[importType]?.importsSet;
+  if (!importSet) {
+    runtimeImports[importType] = {
+      type: importType,
+      specifier,
+      importsSet: new Set<string>().add(importedName),
+    };
+  } else {
+    importSet.add(importedName);
+  }
+}
+
+export function clearImportSets(runtimeImports: Imports): void {
+  for (const importType of Object.values(runtimeImports)) {
+    importType.importsSet?.clear();
+  }
+}
+
+export function addImportsToFiles(
+  runtimeImports: Imports,
+  file: SourceFile,
+  internalSpecifierMap?: Record<string, string>,
+): void {
+  Object.values(runtimeImports)
+    .filter((importType) => {
+      return importType.importsSet?.size;
+    })
+    .forEach((importType) => {
+      const specifier = internalSpecifierMap?.[importType.type] ?? importType.specifier!;
+      let hasModifier = false;
+      if (!specifier) {
+        return;
+      }
+      file
+        .getImportDeclarations()
+        .filter((importDeclaration) => {
+          return importDeclaration.getModuleSpecifierValue() === specifier;
+        })
+        .forEach((importDeclaration) => {
+          hasModifier = true;
+          importDeclaration.addNamedImports([...importType.importsSet!.values()]);
+        });
+
+      if (!hasModifier) {
+        file.addImportDeclaration({
+          isTypeOnly: true,
+          moduleSpecifier: specifier,
+          namedImports: [...importType.importsSet!.values()],
+        });
+        return;
+      }
+    });
+  clearImportSets(runtimeImports);
+}

package/src/rlc-common/helpers/name-constructors.ts

@@ -0,0 +1,88 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+import { RLCModel } from "../interfaces.js";
+import { NameType, normalizeName } from "./name-utils.js";
+
+/**
+ * Get the response type name by baseName or operatioName & statusCode
+ * @param baseResponseName
+ */
+export function getResponseTypeName(baseResponseName: string): string;
+export function getResponseTypeName(
+  operationGroup: string,
+  operationName: string,
+  statusCode: string,
+): string;
+export function getResponseTypeName(
+  baseNameOrOperationGroup: string,
+  operationName?: string,
+  statusCode?: string,
+): string {
+  if (operationName) {
+    baseNameOrOperationGroup = getResponseBaseName(
+      baseNameOrOperationGroup,
+      operationName!,
+      statusCode || "",
+    );
+  }
+  return normalizeName(`${baseNameOrOperationGroup}Response`, NameType.Interface);
+}
+
+export function getLroLogicalResponseName(operationGroup: string, operationName: string) {
+  return normalizeName(`${operationGroup}_${operationName}_Logical_Response`, NameType.Interface);
+}
+
+/**
+ * The prefix of all response types
+ * @param operationGroup operation group name e.g string_PutEmpty
+ * @param operationName operation name D e.g string_PutEmpty
+ * @param statusCode 2XX, 4XX, 5XX, default etc.
+ * @returns normolized base name e.g StringPutEmpty200
+ */
+export function getResponseBaseName(
+  operationGroup: string,
+  operationName: string,
+  statusCode: string,
+) {
+  return normalizeName(
+    `${operationGroup}_${normalizeName(operationName, NameType.Interface, true)}_${statusCode}`,
+    NameType.Interface,
+  );
+}
+
+/**
+ * The prefix of all parameter relevant types
+ * @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);
+}
+
+/**
+ * Get the top-layer parameter name
+ * @param operationGroup operation group name
+ * @param operationName is composed with operationGroup and operationID e.g string_PutEmpty
+ * @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) {
+  if (operationName) {
+    baseNameOrOperationGroup = getParameterBaseName(baseNameOrOperationGroup, operationName!);
+  }
+
+  return normalizeName(`${baseNameOrOperationGroup}_Parameters`, NameType.Interface);
+}
+
+export function getClientName(model: RLCModel) {
+  return model.libraryName;
+}
+
+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);
+}

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

@@ -0,0 +1,138 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+import { MethodSignatureStructure, OptionalKind, ParameterDeclarationStructure } from "ts-morph";
+import {
+  Methods,
+  ObjectSchema,
+  ParameterMetadata,
+  PathParameter,
+  RLCModel,
+  Schema,
+  SchemaContext,
+} from "../interfaces.js";
+import { NameType, normalizeName, pascalCase } from "./name-utils.js";
+import { isObjectSchema } from "./schema-helpers.js";
+
+export function buildMethodDefinitions(
+  methods: Methods,
+  pathParams: PathParameter[] = [],
+): OptionalKind<MethodSignatureStructure>[] {
+  const methodDefinitions: OptionalKind<MethodSignatureStructure>[] = [];
+  for (const key of Object.keys(methods)) {
+    const verbMethods = methods[key];
+    if (!verbMethods) {
+      continue;
+    }
+    for (const method of verbMethods) {
+      const description = method.description;
+      const areAllOptional = method.hasOptionalOptions;
+
+      methodDefinitions.push({
+        name: key,
+        ...(description && { docs: [{ description }] }),
+        parameters: [
+          ...getPathParamDefinitions(pathParams),
+          {
+            name: "options",
+            hasQuestionToken: areAllOptional,
+            type: pascalCase(method.optionsName),
+          },
+        ],
+        returnType: `StreamableMethod<${method.returnType}>`,
+      });
+    }
+  }
+
+  return methodDefinitions;
+}
+
+export function getPathParamDefinitions(
+  pathParams: PathParameter[],
+): OptionalKind<ParameterDeclarationStructure>[] {
+  return pathParams.map(({ name, type, description }) => {
+    return {
+      name: normalizeName(name, NameType.Parameter),
+      type,
+      description,
+    };
+  });
+}
+
+export function hasPagingOperations(model: RLCModel) {
+  return Boolean(model.helperDetails?.hasPaging);
+}
+
+export function hasPollingOperations(model: RLCModel) {
+  return Boolean(model.helperDetails?.hasLongRunning);
+}
+
+export function hasMultiCollection(model: RLCModel) {
+  return Boolean(model.helperDetails?.hasMultiCollection);
+}
+
+export function hasPipeCollection(model: RLCModel) {
+  return Boolean(model.helperDetails?.hasPipeCollection);
+}
+
+export function hasSsvCollection(model: RLCModel) {
+  return Boolean(model.helperDetails?.hasSsvCollection);
+}
+
+export function hasTsvCollection(model: RLCModel) {
+  return Boolean(model.helperDetails?.hasTsvCollection);
+}
+
+export function hasCsvCollection(model: RLCModel) {
+  return Boolean(model.helperDetails?.hasCsvCollection);
+}
+
+export function hasUnexpectedHelper(model: RLCModel) {
+  const pathDictionary = model.paths;
+  for (const details of Object.values(pathDictionary)) {
+    for (const methodDetails of Object.values(details.methods)) {
+      const firstMethod = methodDetails[0];
+      if (!firstMethod) {
+        continue;
+      }
+      const successTypes = firstMethod.responseTypes.success;
+      const errorTypes = firstMethod.responseTypes.error;
+
+      if (successTypes.length > 0 && errorTypes.length > 0 && !!errorTypes[0]) {
+        return true;
+      }
+    }
+  }
+  return false;
+}
+
+export function hasInputModels(model: RLCModel) {
+  return hasSchemaContextObject(model, [SchemaContext.Input]);
+}
+export function hasOutputModels(model: RLCModel) {
+  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)),
+  );
+
+  return objectSchemas.length > 0;
+}
+
+export function getGeneratedWrapperTypes(params: ParameterMetadata[] | PathParameter[]): Schema[] {
+  const wrapperTypes = params
+    .map((qp) => (isParameterMetadata(qp) ? qp.param.wrapperType : qp.wrapperType))
+    .filter((v) => v !== undefined);
+  const wrapperFromObjects = wrapperTypes.filter((wrap) => wrap.type === "object");
+  const wrapperFromUnions = wrapperTypes
+    .filter((wrap) => wrap.type === "union")
+    .flatMap((wrapperType) => wrapperType?.enum ?? [])
+    .filter((v) => v.type === "object");
+  return [...wrapperFromUnions, ...wrapperFromObjects];
+}
+
+function isParameterMetadata(param: ParameterMetadata | PathParameter): param is ParameterMetadata {
+  return (param as any).param !== undefined;
+}

package/src/rlc-common/index.ts

@@ -1,43 +1,25 @@
 // Copyright (c) Microsoft Corporation.
 // Licensed under the MIT License.
 
-export * from "./buildClient.js";
-export * from "./buildClientDefinitions.js";
-export * from "./buildIndexFile.js";
-export * from "./buildIsUnexpectedHelper.js";
-export * from "./buildLogger.js";
-export * from "./buildPaginateHelper.js";
-export * from "./buildParameterTypes.js";
-export * from "./buildPollingHelper.js";
-export * from "./buildResponseTypes.js";
-export * from "./buildSamples.js";
-export * from "./buildSchemaType.js";
-export * from "./buildSerializeHelper.js";
-export * from "./buildTopLevelIndexFile.js";
-export * from "./helpers/apiVersionUtil.js";
-export * from "./helpers/importsUtil.js";
-export * from "./helpers/nameConstructors.js";
-export * from "./helpers/nameUtils.js";
-export * from "./helpers/operationHelpers.js";
-export * from "./helpers/packageUtil.js";
-export * from "./helpers/schemaHelpers.js";
-export * from "./helpers/shortcutMethods.js";
-export * from "./helpers/valueGenerationUtil.js";
+export * from "./helpers/api-version-util.js";
+export * from "./helpers/imports-util.js";
+export * from "./helpers/name-constructors.js";
+export * from "./helpers/name-utils.js";
+export * from "./helpers/operation-helpers.js";
+export * from "./helpers/schema-helpers.js";
 export * from "./interfaces.js";
-export * from "./metadata/buildApiExtractorConfig.js";
-export * from "./metadata/buildChangelogFile.js";
-export * from "./metadata/buildESLintConfig.js";
-export * from "./metadata/buildLicenseFile.js";
-export * from "./metadata/buildPackageFile.js";
-export * from "./metadata/buildReadmeFile.js";
-export * from "./metadata/buildRollupConfig.js";
-export * from "./metadata/buildSampleEnvFile.js";
-export * from "./metadata/buildTestConfig.js";
-export * from "./metadata/buildTsConfig.js";
-export * from "./metadata/buildVitestConfig.js";
-export * from "./metadata/buildWarpConfig.js";
-export * from "./test/buildKarmaConfig.js";
-export * from "./test/buildRecordedClient.js";
-export * from "./test/buildSampleTest.js";
-export * from "./test/buildSnippets.js";
-export * from "./transformSampleGroups.js";
+export * from "./metadata/build-api-extractor-config.js";
+export * from "./metadata/build-changelog-file.js";
+export * from "./metadata/build-es-lint-config.js";
+export * from "./metadata/build-license-file.js";
+export * from "./metadata/build-package-file.js";
+export * from "./metadata/build-readme-file.js";
+export * from "./metadata/build-sample-env-file.js";
+export * from "./metadata/build-test-config.js";
+export * from "./metadata/build-ts-config.js";
+export * from "./metadata/build-vitest-config.js";
+export * from "./metadata/build-warp-config.js";
+export * from "./test/build-karma-config.js";
+export * from "./test/build-recorded-client.js";
+export * from "./test/build-sample-test.js";
+export * from "./test/build-snippets.js";