@azure-tools/typespec-ts 0.54.1 → 0.54.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@azure-tools/typespec-ts",
-  "version": "0.54.1",
+  "version": "0.54.2",
   "description": "An experimental TypeSpec emitter for TypeScript RLC",
   "main": "dist/src/index.js",
   "type": "module",
@@ -25,11 +25,8 @@
     "@azure/core-rest-pipeline": "^1.14.0",
     "@azure/core-util": "^1.4.0",
     "@azure/logger": "^1.0.4",
-    "@typescript-eslint/eslint-plugin": "^8.28.0",
-    "@typescript-eslint/parser": "^8.58.1",
     "@typespec/ts-http-runtime": "0.3.5",
     "cross-env": "^10.1.0",
-    "eslint-plugin-require-extensions": "0.1.3",
     "mkdirp": "^3.0.1",
     "npm-run-all": "~4.1.5",
     "prettier": "^3.8.1",
@@ -39,30 +36,30 @@
     "@microsoft/api-extractor": "^7.58.1",
     "tsx": "^4.21.0",
     "yaml": "^2.8.3",
-    "@typespec/http-specs": "^0.1.0-alpha.37",
-    "@typespec/spector": "^0.1.0-alpha.25",
+    "@typespec/tspd": "^0.75.0",
     "@typespec/spec-api": "^0.1.0-alpha.14",
-    "@azure-tools/typespec-autorest": "^0.68.0",
-    "@azure-tools/azure-http-specs": "^0.1.0-alpha.40",
-    "@typespec/tspd": "^0.74.2",
-    "@azure-tools/typespec-azure-core": "^0.68.0",
-    "@azure-tools/typespec-azure-resource-manager": "^0.68.0",
-    "@azure-tools/typespec-client-generator-core": "^0.68.4",
-    "@typespec/compiler": "^1.12.0",
-    "@typespec/http": "^1.12.0",
-    "@typespec/openapi": "^1.12.0",
-    "@typespec/rest": "^0.82.0",
-    "@typespec/xml": "^0.82.0",
-    "@typespec/versioning": "^0.82.0"
+    "@typespec/spector": "^0.1.0-alpha.25",
+    "@azure-tools/typespec-autorest": "^0.69.1",
+    "@azure-tools/azure-http-specs": "^0.1.0-alpha.42",
+    "@typespec/http-specs": "^0.1.0-alpha.38",
+    "@azure-tools/typespec-azure-core": "^0.69.0",
+    "@azure-tools/typespec-client-generator-core": "^0.69.0",
+    "@typespec/compiler": "^1.13.0",
+    "@typespec/openapi": "^1.13.0",
+    "@typespec/rest": "^0.83.0",
+    "@typespec/http": "^1.13.0",
+    "@typespec/versioning": "^0.83.0",
+    "@typespec/xml": "^0.83.0",
+    "@azure-tools/typespec-azure-resource-manager": "^0.69.1"
   },
   "peerDependencies": {
-    "@azure-tools/typespec-azure-core": "^0.68.0",
-    "@azure-tools/typespec-client-generator-core": "^0.68.4",
-    "@typespec/http": "^1.12.0",
-    "@typespec/rest": "^0.82.0",
-    "@typespec/versioning": "^0.82.0",
-    "@typespec/compiler": "^1.12.0",
-    "@typespec/xml": "^0.82.0"
+    "@azure-tools/typespec-azure-core": "^0.69.0",
+    "@typespec/compiler": "^1.13.0",
+    "@azure-tools/typespec-client-generator-core": "^0.69.0",
+    "@typespec/rest": "^0.83.0",
+    "@typespec/versioning": "^0.83.0",
+    "@typespec/http": "^1.13.0",
+    "@typespec/xml": "^0.83.0"
   },
   "dependencies": {
     "fast-xml-parser": "^5.7.0",
@@ -95,11 +92,10 @@
     "test": "npm run test-next && npm run unit-test && npm run integration-test-ci",
     "test:azure": "npm run test-next && npm run copy:typespec && npm run integration-test-ci:azure-rlc && npm run integration-test-ci:azure-modular",
     "test:standard": "npm run test-next && npm run copy:typespec && npm run unit-test&& npm run integration-test-ci:rlc && npm run integration-test-ci:modular",
-    "lint": "eslint src --ext .ts --max-warnings=0",
-    "lint:fix": "eslint src --fix --ext .ts",
+    "lint": "eslint . --ext .ts --max-warnings=0",
+    "lint:fix": "eslint . --fix --ext .ts",
     "check:tree": "tsx ./test/commands/check-clean-tree.ts",
     "test:ts:e2e": "npm run copy:typespec && npm run integration-test-ci:azure-rlc && npm run integration-test-ci:azure-modular",
-    "prettier": "prettier --config ./.prettierrc \"{src,test,static}/**/*.ts\" \"!test/**/generated/**/*.ts\"",
     "integration-test-ci": "npm-run-all copy:typespec integration-test-ci:rlc integration-test-ci:azure-rlc integration-test-ci:modular integration-test-ci:azure-modular",
     "integration-test-ci:sequential": "npm-run-all --serial copy:typespec integration-test-ci:modular && npm run integration-test-ci:modular",
     "integration-test-ci:rlc": "npm-run-all --silent -p start-test-server:rlc --race generate-and-run:rlc",

package/src/context-manager.ts

@@ -0,0 +1,101 @@
+import { SdkContext } from "@azure-tools/typespec-client-generator-core";
+import { EmitContext } from "@typespec/compiler";
+import { Project, SourceFile } from "ts-morph";
+import { ExternalDependencies } from "./framework/dependency.js";
+import { Binder } from "./framework/hooks/binder.js";
+import { SdkTypeContext } from "./framework/hooks/sdk-types.js";
+import { RlcMetaTree } from "./meta-tree.js";
+
+/**
+ * Contexts Object Guidelines
+ * --------------------------
+ * The `Contexts` object contains various application-wide data that needs to be accessible across different parts of the program without the need to pass down props deeply.
+ *
+ * When to add a new context:
+ * - **Cross-Cutting Concerns**: Add a new context when the data or functionality is a cross-cutting concern used by multiple unrelated components or modules.
+ * - **Global State**: If the state needs to be globally accessible and mutable by different parts of the application, and does not belong to a specific component or module.
+ * - **Performance Optimization**: To avoid unnecessary compute or prop drilling that may lead to performance bottlenecks, especially when passing down props through many levels.
+ * - **Shared Resources**: For resources that are shared across various parts of the application, such as settings, configurations, or metadata.
+ *
+ * Remember, adding too many contexts can lead to complex dependencies and harder-to-maintain code. Always evaluate if the context is truly necessary or if there are better alternatives such as localized state management or passing props for simpler scenarios.
+ */
+type Contexts = {
+  rlcMetaTree: RlcMetaTree; // Context for RLC types metadata.
+  outputProject: Project; // The TS-Morph root project context for code generation.
+  symbolMap: Map<string, SourceFile>; // Mapping of symbols to their corresponding source files.
+  sdkTypes: SdkTypeContext;
+  emitContext: {
+    compilerContext: EmitContext;
+    tcgcContext: SdkContext;
+  };
+  binder: Binder;
+  dependencies: ExternalDependencies;
+};
+
+type ContextKey = keyof Contexts;
+
+/**
+ * Manages shared contexts across the application to minimize prop drilling and enhance modularity.
+ * Implements the Singleton pattern to ensure there is a single instance of ContextManager.
+ */
+class ContextManager {
+  private static instance: ContextManager;
+  private contexts: Map<ContextKey, any> = new Map();
+
+  private constructor() {}
+
+  /**
+   * Retrieves the singleton instance of the ContextManager.
+   * @returns {ContextManager} The singleton instance.
+   */
+  public static getInstance(): ContextManager {
+    if (!ContextManager.instance) {
+      ContextManager.instance = new ContextManager();
+    }
+    return ContextManager.instance;
+  }
+
+  /**
+   * Sets a value for a specific context key.
+   * @param {ContextKey} key - The key of the context to set.
+   * @param {Contexts[K]} value - The value to set for the specified context.
+   */
+  public setContext<K extends ContextKey>(key: K, value: Contexts[K]): void {
+    this.contexts.set(key, value);
+  }
+
+  /**
+   * Retrieves the context value for a specific key.
+   * @param {ContextKey} key - The key of the context to retrieve.
+   * @returns {Contexts[K] | undefined} The value of the context if found, otherwise undefined.
+   */
+  public getContext<K extends ContextKey>(key: K): Contexts[K] | undefined {
+    return this.contexts.get(key) as Contexts[K] | undefined;
+  }
+}
+
+// Expose the singleton instance of the context manager.
+export const contextManager = ContextManager.getInstance();
+
+/**
+ * A utility function to use a context by key.
+ * @param {ContextKey} key - The key of the context to retrieve.
+ * @throws Will throw an error if the context is not found.
+ * @returns {Contexts[K]} The context value.
+ */
+export function useContext<K extends ContextKey>(key: K): Contexts[K] {
+  const context = contextManager.getContext(key);
+  if (!context) {
+    throw new Error(`Context ${key} not found`);
+  }
+  return context;
+}
+
+/**
+ * Provides a context with a value to be accessible across the program.
+ * @param {ContextKey} key - The key of the context to provide.
+ * @param {Contexts[K]} value - The value to set for the specified context.
+ */
+export function provideContext<K extends ContextKey>(key: K, value: Contexts[K]): void {
+  contextManager.setContext(key, value);
+}

package/src/framework/hooks/binder.ts

@@ -7,12 +7,12 @@ import {
   SourceFile,
   StructureKind,
 } from "ts-morph";
-import { provideContext, useContext } from "../../contextManager.js";
-import { generateLocallyUniqueName } from "../../modular/helpers/namingHelpers.js";
+import { provideContext, useContext } from "../../context-manager.js";
+import { generateLocallyUniqueName } from "../../modular/helpers/naming-helpers.js";
 import { ReferenceableSymbol } from "../dependency.js";
 import { SourceFileSymbol, StaticHelperMetadata } from "../load-static-helpers.js";
 import { refkey } from "../refkey.js";
-import { provideDependencies, useDependencies } from "./useDependencies.js";
+import { provideDependencies, useDependencies } from "./use-dependencies.js";
 
 export interface DeclarationInfo {
   name: string;

package/src/framework/hooks/sdk-types.ts

@@ -0,0 +1,219 @@
+import {
+  SdkClientType,
+  SdkHttpOperation,
+  SdkModelPropertyType,
+  SdkModelType,
+  SdkServiceMethod,
+  SdkType,
+  getClientType,
+} from "@azure-tools/typespec-client-generator-core";
+import { Operation, Type, getNamespaceFullName } from "@typespec/compiler";
+import { provideContext, useContext } from "../../context-manager.js";
+
+import { reportDiagnostic } from "../../lib.js";
+import { visitPackageTypes } from "../../modular/emit-models.js";
+import { getAllAncestors, getAllProperties } from "../../modular/helpers/operation-helpers.js";
+import { normalizeModelPropertyName } from "../../modular/type-expressions/get-type-expression.js";
+import { NameType, normalizeName } from "../../rlc-common/index.js";
+import { SdkContext } from "../../utils/interfaces.js";
+
+export const emitQueue: Set<SdkType> = new Set<SdkType>();
+export const flattenPropertyModelMap: Map<SdkModelPropertyType, SdkModelType> = new Map<
+  SdkModelPropertyType,
+  SdkModelType
+>();
+/**
+ * Set of paged result models that should keep their public name (no "_" prefix).
+ * This includes models used as non-paging method responses or as model properties.
+ * Precomputed during visitPackageTypes for O(1) lookups in normalizeModelName.
+ */
+export const pagedModelsKeptPublic = new Set<SdkType>();
+
+export interface SdkTypeContext {
+  operations: Map<Type, SdkServiceMethod<SdkHttpOperation>>;
+  types: Map<Type, SdkType>;
+  flattenProperties: Map<SdkModelPropertyType, SdkFlattenPropertyContext>;
+}
+
+export interface SdkFlattenPropertyContext {
+  baseModel: SdkModelType;
+  conflictMap?: Map<SdkModelPropertyType, string>;
+}
+
+export function useSdkTypes() {
+  const sdkTypesContext = useContext("sdkTypes");
+  const { tcgcContext } = useContext("emitContext");
+
+  function getSdkType(type: Operation): SdkServiceMethod<SdkHttpOperation>;
+  function getSdkType(type: Type): SdkType;
+  function getSdkType(type: Type | Operation): SdkType | SdkServiceMethod<SdkHttpOperation> {
+    let sdkType: SdkType | SdkServiceMethod<SdkHttpOperation> | undefined;
+
+    if (type.kind === "Operation") {
+      sdkType = sdkTypesContext.operations.get(type);
+    } else {
+      sdkType = sdkTypesContext.types.get(type) ?? getClientType(tcgcContext, type);
+    }
+
+    if (!sdkType) {
+      throw new Error(
+        `SdkType not found for type: ${type.kind} ${
+          "name" in type && typeof type.name === "string" ? type.name : ""
+        } ${
+          "namespace" in type && type.namespace ? ` in ${getNamespaceFullName(type.namespace)}` : ""
+        }`,
+      );
+    }
+
+    return sdkType;
+  }
+
+  return getSdkType;
+}
+
+export function provideSdkTypes(context: SdkContext) {
+  const { sdkPackage } = context;
+  const sdkTypesContext: SdkTypeContext = {
+    operations: new Map<Type, SdkServiceMethod<SdkHttpOperation>>(),
+    types: new Map<Type, SdkType>(),
+    flattenProperties: new Map<SdkModelPropertyType, SdkFlattenPropertyContext>(),
+  };
+  visitPackageTypes(context);
+  enrichFlattenProperties(context, sdkTypesContext.flattenProperties, flattenPropertyModelMap);
+  for (const sdkModel of emitQueue) {
+    switch (sdkModel.kind) {
+      case "model":
+        sdkModel.properties.forEach((prop) => {
+          sdkTypesContext.types.set(prop.type.__raw!, prop.type);
+        });
+        if (sdkModel.discriminatedSubtypes) {
+          Object.values(sdkModel.discriminatedSubtypes).forEach((subtype) => {
+            sdkTypesContext.types.set(subtype.__raw!, subtype);
+          });
+        }
+        break;
+      case "enum":
+        if (sdkModel.__raw) {
+          sdkTypesContext.types.set(sdkModel.__raw, sdkModel);
+        }
+        break;
+      case "union":
+        sdkModel.variantTypes.forEach((v) => {
+          if (v.__raw) {
+            sdkTypesContext.types.set(v.__raw, v);
+          }
+        });
+        break;
+      case "array":
+        sdkTypesContext.types.set(sdkModel.valueType.__raw!, sdkModel.valueType);
+        break;
+      case "dict":
+        sdkTypesContext.types.set(sdkModel.valueType.__raw!, sdkModel.valueType);
+        break;
+      case "nullable":
+        sdkTypesContext.types.set(sdkModel.__raw!, sdkModel);
+        sdkTypesContext.types.set(sdkModel.type.__raw!, sdkModel.type);
+        break;
+    }
+    if (!sdkModel.__raw) {
+      continue;
+    }
+    sdkTypesContext.types.set(sdkModel.__raw, sdkModel);
+  }
+
+  for (const client of sdkPackage.clients) {
+    for (const method of getAllOperationsFromClient(client)) {
+      if (!method.__raw) {
+        continue;
+      }
+
+      sdkTypesContext.operations.set(method.__raw, method);
+
+      // Visit the parameters of the method to add them to the types map
+      method.parameters.forEach((param) => {
+        sdkTypesContext.types.set(param.type.__raw!, param.type);
+      });
+    }
+  }
+
+  provideContext("sdkTypes", sdkTypesContext);
+}
+
+// Enrich flatten properties with their base models and conflict maps
+function enrichFlattenProperties(
+  context: SdkContext,
+  propertyContextMap: Map<SdkModelPropertyType, SdkFlattenPropertyContext>,
+  propertyModelMap: Map<SdkModelPropertyType, SdkModelType>,
+) {
+  // Build a map of base model to its existing properties excluding flatten properties
+  // To check for conflicts later
+  const baseModelProperties = new Map<SdkModelType, Set<string>>();
+  propertyModelMap.forEach((baseModel, _) => {
+    if (!baseModelProperties.has(baseModel)) {
+      const propertiesExcludedFlatten = getAllProperties(
+        context,
+        baseModel,
+        getAllAncestors(baseModel),
+      )
+        .filter((p) => !(p.flatten && p.type.kind === "model"))
+        .map((p) => normalizeModelPropertyName(context, p));
+      baseModelProperties.set(baseModel, new Set<string>(propertiesExcludedFlatten));
+    }
+  });
+  for (const [flattenProperty, baseModel] of propertyModelMap) {
+    const flattenContext: SdkFlattenPropertyContext = {
+      baseModel: baseModel,
+    };
+    propertyContextMap.set(flattenProperty, flattenContext);
+    const existingProperties = baseModelProperties.get(baseModel)!;
+    const conflictMap = new Map<SdkModelPropertyType, string>();
+    const flattenModel = flattenProperty.type;
+
+    if (baseModelProperties.has(flattenModel as SdkModelType)) {
+      // If the flatten model is also a base model of other flatten properties, which means it has multiple consecutive flatten operations
+      // Since we cannot handle the flatten transition, report warning and skip it for now
+      reportDiagnostic(context.program, {
+        code: "unsupported-flatten-transition",
+        format: {
+          propertyName: flattenProperty.name,
+          modelName: baseModel.name,
+        },
+        target: flattenProperty.__raw!,
+      });
+    }
+    const allFlattenProperties = getAllProperties(
+      context,
+      flattenModel,
+      getAllAncestors(flattenModel),
+    );
+    for (const flattenChildProperty of allFlattenProperties) {
+      let childPropertyName = normalizeModelPropertyName(context, flattenChildProperty);
+      if (existingProperties.has(childPropertyName)) {
+        childPropertyName = normalizeName(
+          `${childPropertyName}_${flattenProperty.name}_${childPropertyName}`,
+          NameType.Property,
+        );
+        conflictMap.set(flattenChildProperty, childPropertyName);
+      }
+      existingProperties.add(childPropertyName);
+    }
+    if (conflictMap.size === 0) {
+      continue;
+    }
+    flattenContext.conflictMap = conflictMap;
+  }
+}
+
+export function getAllOperationsFromClient(client: SdkClientType<SdkHttpOperation>) {
+  const clientQueue = [client];
+  const operations: SdkServiceMethod<SdkHttpOperation>[] = [];
+  while (clientQueue.length > 0) {
+    const client = clientQueue.pop()!;
+    if (client.children) {
+      clientQueue.push(...client.children);
+    }
+    operations.push(...client.methods);
+  }
+
+  return operations;
+}

package/src/framework/hooks/use-dependencies.ts

@@ -0,0 +1,16 @@
+import { provideContext, useContext } from "../../context-manager.js";
+import { DefaultCoreDependencies } from "../../modular/external-dependencies.js";
+import { ExternalDependencies } from "../dependency.js";
+
+export function provideDependencies(customDependencies: Partial<ExternalDependencies> = {}) {
+  const dependencies = {
+    ...DefaultCoreDependencies,
+    ...customDependencies,
+  } as ExternalDependencies;
+
+  provideContext("dependencies", dependencies);
+}
+
+export function useDependencies(): ExternalDependencies {
+  return useContext("dependencies");
+}

package/src/index.ts

@@ -2,8 +2,8 @@
 // Licensed under the MIT License.
 
 import { EmitContext, Program } from "@typespec/compiler";
-import { provideContext, useContext } from "./contextManager.js";
-import { buildRootIndex, buildSubClientIndexFile } from "./modular/buildRootIndex.js";
+import { provideContext, useContext } from "./context-manager.js";
+import { buildRootIndex, buildSubClientIndexFile } from "./modular/build-root-index.js";
 import {
   AzureCoreDependencies,
   AzureIdentityDependencies,
@@ -69,8 +69,8 @@ import {
   updatePackageFile,
   updateReadmeFile,
 } from "./rlc-common/index.js";
-import { emitContentByBuilder, emitModels } from "./utils/emitUtil.js";
-import { clearDirectory, emptyDir, pathExists } from "./utils/fileSystemUtils.js";
+import { emitContentByBuilder, emitModels } from "./utils/emit-util.js";
+import { clearDirectory, emptyDir, pathExists } from "./utils/file-system-utils.js";
 import { GenerationDirDetail, SdkContext } from "./utils/interfaces.js";
 
 import {
@@ -83,33 +83,33 @@ import { existsSync } from "fs";
 import { basename, join } from "path";
 import { Project } from "ts-morph";
 import { provideBinder } from "./framework/hooks/binder.js";
-import { provideSdkTypes } from "./framework/hooks/sdkTypes.js";
+import { provideSdkTypes } from "./framework/hooks/sdk-types.js";
 import { loadStaticHelpers } from "./framework/load-static-helpers.js";
 import { EmitterOptions } from "./lib.js";
-import { buildClassicalClient } from "./modular/buildClassicalClient.js";
-import { buildClassicOperationFiles } from "./modular/buildClassicalOperationGroups.js";
-import { buildClientContext, getClientContextPath } from "./modular/buildClientContext.js";
-import { transformModularEmitterOptions } from "./modular/buildModularOptions.js";
-import { buildOperationFiles } from "./modular/buildOperations.js";
-import { getModuleExports } from "./modular/buildProjectFiles.js";
-import { buildRestorePoller } from "./modular/buildRestorePoller.js";
-import { buildSubpathIndexFile } from "./modular/buildSubpathIndex.js";
-import { emitLoggerFile } from "./modular/emitLoggerFile.js";
-import { emitNonModelResponseTypes, emitTypes } from "./modular/emitModels.js";
-import { buildApiOptions } from "./modular/emitModelsOptions.js";
-import { emitSamples } from "./modular/emitSamples.js";
-import { emitTests } from "./modular/emitTests.js";
-import { getClassicalClientName } from "./modular/helpers/namingHelpers.js";
+import { buildClassicalClient } from "./modular/build-classical-client.js";
+import { buildClassicOperationFiles } from "./modular/build-classical-operation-groups.js";
+import { buildClientContext, getClientContextPath } from "./modular/build-client-context.js";
+import { transformModularEmitterOptions } from "./modular/build-modular-options.js";
+import { buildOperationFiles } from "./modular/build-operations.js";
+import { getModuleExports } from "./modular/build-project-files.js";
+import { buildRestorePoller } from "./modular/build-restore-poller.js";
+import { buildSubpathIndexFile } from "./modular/build-subpath-index.js";
+import { emitLoggerFile } from "./modular/emit-logger-file.js";
+import { buildApiOptions } from "./modular/emit-models-options.js";
+import { emitNonModelResponseTypes, emitTypes } from "./modular/emit-models.js";
+import { emitSamples } from "./modular/emit-samples.js";
+import { emitTests } from "./modular/emit-tests.js";
+import { getClassicalClientName } from "./modular/helpers/naming-helpers.js";
 import { ModularEmitterOptions } from "./modular/interfaces.js";
-import { packageUsesXmlSerialization } from "./modular/serialization/buildXmlSerializerFunction.js";
+import { packageUsesXmlSerialization } from "./modular/serialization/build-xml-serializer-function.js";
 import { transformRLCModel } from "./transform/transform.js";
-import { transformRLCOptions } from "./transform/transfromRLCOptions.js";
+import { transformRLCOptions } from "./transform/transfrom-rlc-options.js";
 import {
   getClientHierarchyMap,
   getModularClientOptions,
   getRLCClients,
-} from "./utils/clientUtils.js";
-import { generateCrossLanguageDefinitionFile } from "./utils/crossLanguageDef.js";
+} from "./utils/client-utils.js";
+import { generateCrossLanguageDefinitionFile } from "./utils/cross-language-def.js";
 
 export * from "./lib.js";