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

package/src/rlc-common/helpers/shortcut-methods.ts

@@ -0,0 +1,58 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+import { InterfaceDeclarationStructure, MethodSignatureStructure, OptionalKind } from "ts-morph";
+import { PathMetadata, Paths } from "../interfaces.js";
+import { NameType, normalizeName } from "./name-utils.js";
+import { buildMethodDefinitions } from "./operation-helpers.js";
+
+export function generateMethodShortcuts(
+  paths: Paths,
+): OptionalKind<InterfaceDeclarationStructure>[] {
+  const keys: Record<string, OptionalKind<MethodSignatureStructure>[]> = {};
+  for (const path in paths) {
+    const pathMetadata = paths[path];
+    if (!pathMetadata) {
+      continue;
+    }
+    const groupName = pathMetadata.operationGroupName;
+    const definitions = buildOperationDefinitions(pathMetadata);
+    if (!keys[groupName]) {
+      keys[groupName] = definitions;
+    } else {
+      keys[groupName] = [...keys[groupName], ...definitions];
+    }
+  }
+
+  const interfaces: OptionalKind<InterfaceDeclarationStructure>[] = [];
+
+  for (const interfaceName in keys) {
+    const methods = keys[interfaceName];
+    interfaces.push({
+      name: `${interfaceName}Operations`,
+      methods: methods,
+      isExported: true,
+      docs: [`Contains operations for ${interfaceName} operations`],
+    });
+  }
+
+  return interfaces;
+}
+
+function buildOperationDefinitions(path: PathMetadata): OptionalKind<MethodSignatureStructure>[] {
+  let ops: OptionalKind<MethodSignatureStructure>[] = [];
+
+  for (const verb in path.methods) {
+    const methods = path.methods[verb];
+    if (!methods) {
+      continue;
+    }
+    for (const method of methods) {
+      const name = normalizeName(method.operationName, NameType.Property);
+      const pathParams = path.pathParameters;
+      const methodDefinitions = buildMethodDefinitions({ [name]: [method] }, pathParams);
+      ops = [...ops, ...methodDefinitions];
+    }
+  }
+  return ops;
+}

package/src/rlc-common/helpers/value-generation-util.ts

@@ -0,0 +1,234 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+import { getImmediateParentsNames } from "../build-object-types.js";
+import {
+  ArraySchema,
+  DictionarySchema,
+  ObjectSchema,
+  Schema,
+  SchemaContext,
+} from "../interfaces.js";
+import {
+  TypeScriptType,
+  getArrayObjectType,
+  getNativeArrayType,
+  getRecordType,
+  getUnionType,
+  isArrayObject,
+  isNativeArray,
+  leaveBracket,
+  leaveStringQuotes,
+  toTypeScriptTypeFromName,
+  toTypeScriptTypeFromSchema,
+} from "./type-util.js";
+
+/**
+ * Generate parameter type value for the given type and parameter name
+ * @param type the typescript type
+ * @param parameterName the parameter name
+ * @param schemaMap the schema info to help generate the value
+ * @param path optional path to help detect self reference
+ * @param _allowMockValue the flag to indicate whether to allow mock value, currently we always generate mock value
+ * @returns
+ */
+export function generateParameterTypeValue(
+  type: string,
+  parameterName: string,
+  schemaMap: Map<string, Schema>,
+  path: Set<string> = new Set(),
+  _allowMockValue = true,
+): string | undefined {
+  type = leaveBracket(type?.trim());
+  let tsType: TypeScriptType | undefined;
+  // Give priority to suggest the ts-type from schema
+  if (schemaMap.has(type)) {
+    tsType = toTypeScriptTypeFromSchema(schemaMap.get(type)!);
+  }
+  // Fallback to suggest ts-type from the type iteself
+  if (!tsType) {
+    tsType = toTypeScriptTypeFromName(type);
+  }
+  switch (tsType) {
+    case TypeScriptType.string:
+      return `"{Your ${leaveStringQuotes(parameterName)}}"`;
+    case TypeScriptType.number:
+      return "123";
+    case TypeScriptType.boolean:
+      return "true";
+    case TypeScriptType.date:
+      return "new Date()";
+    case TypeScriptType.unknown:
+      return `"Unknown Type"`;
+    case TypeScriptType.object: {
+      return generateObjectValues(type, parameterName, schemaMap, path);
+    }
+    case TypeScriptType.array: {
+      return generateArrayValues(type, parameterName, schemaMap, path);
+    }
+    case TypeScriptType.record: {
+      return generateRecordValues(type, parameterName, schemaMap, path);
+    }
+    case TypeScriptType.enum: {
+      return mockEnumValues(type, parameterName, schemaMap, path);
+    }
+    case TypeScriptType.union: {
+      return mockUnionValues(type, parameterName, schemaMap, path);
+    }
+    case TypeScriptType.constant:
+      return type;
+  }
+  return `undefined /**FIXME */`;
+}
+
+function mockEnumValues(
+  type: string,
+  parameterName: string,
+  schemaMap: Map<string, Schema>,
+  path: Set<string> = new Set(),
+) {
+  const schema = schemaMap.get(type);
+  if (schema && schema.enum && schema.enum.length > 0) {
+    return schema.enum[0].type;
+  }
+  return generateParameterTypeValue(getUnionType(type), parameterName, schemaMap, path);
+}
+
+function mockUnionValues(
+  type: string,
+  parameterName: string,
+  schemaMap: Map<string, Schema>,
+  path: Set<string> = new Set(),
+) {
+  const schema = schemaMap.get(type);
+  if (schema && schema.enum && schema.enum.length > 0) {
+    addToSchemaMap(schemaMap, schema.enum[0]);
+    return generateParameterTypeValue(
+      getAccurateTypeName(schema.enum[0]) ?? schema.enum[0],
+      parameterName,
+      schemaMap,
+      path,
+    );
+  }
+  return generateParameterTypeValue(getUnionType(type), parameterName, schemaMap, path);
+}
+
+function generateRecordValues(
+  type: string,
+  parameterName: string,
+  schemaMap: Map<string, Schema>,
+  path: Set<string> = new Set(),
+) {
+  let recordType = getRecordType(type);
+  const schema = schemaMap.get(type) as DictionarySchema;
+  if (schema && schema.additionalProperties) {
+    recordType = getAccurateTypeName(schema.additionalProperties);
+    addToSchemaMap(schemaMap, schema.additionalProperties);
+  }
+
+  return recordType
+    ? `{"key": ${generateParameterTypeValue(recordType, parameterName, schemaMap, path)}}`
+    : `{}`;
+}
+
+function generateArrayValues(
+  type: string,
+  parameterName: string,
+  schemaMap: Map<string, Schema>,
+  path: Set<string> = new Set(),
+) {
+  let arrayType;
+  const schema = schemaMap.get(type) as ArraySchema;
+  if (schema && schema.items) {
+    arrayType = getAccurateTypeName(schema.items);
+    addToSchemaMap(schemaMap, schema.items);
+  } else if (isArrayObject(type)) {
+    arrayType = getArrayObjectType(type);
+  } else if (isNativeArray(type)) {
+    arrayType = getNativeArrayType(type);
+  }
+  const itemValue = arrayType
+    ? generateParameterTypeValue(arrayType, parameterName, schemaMap, path)
+    : undefined;
+  return itemValue ? `[${itemValue}]` : `[]`;
+}
+
+function generateObjectValues(
+  type: string,
+  _parameterName: string,
+  schemaMap: Map<string, Schema>,
+  path: Set<string> = new Set(),
+) {
+  if (path.has(type)) {
+    // skip generating if self referenced
+    return `{} as any /**FIXME */`;
+  }
+  path.add(type);
+  // Extract all properties from the schema
+  const allProperties = getAllProperties(schemaMap.get(type), schemaMap);
+  const values = extractObjectProperties(allProperties, schemaMap, path);
+
+  path.delete(type);
+  return `{${values.join(", ")}}`;
+}
+
+function getAllProperties(
+  schema?: ObjectSchema,
+  schemaMap: Map<string, Schema> = new Map(),
+): Map<string, Schema> {
+  const propertiesMap: Map<string, Schema> = new Map();
+  if (!schema) {
+    return new Map();
+  }
+  getImmediateParentsNames(schema, [SchemaContext.Input])?.forEach((p) => {
+    const parentProperties = getAllProperties(schemaMap.get(p), schemaMap);
+    for (const prop of parentProperties.keys()) {
+      propertiesMap.set(prop, parentProperties.get(prop)!);
+    }
+  });
+  for (const prop in schema.properties) {
+    const propValue = schema.properties[prop];
+    if (propValue) {
+      propertiesMap.set(prop, propValue);
+    }
+  }
+  return propertiesMap;
+}
+
+function extractObjectProperties(
+  properties: Map<string, Schema>,
+  schemaMap: Map<string, Schema> = new Map(),
+  path: Set<string> = new Set(),
+) {
+  const values: string[] = [];
+  for (const name of properties.keys()) {
+    const property = properties.get(name);
+    if (!property || property.readOnly || property.type === "never") {
+      continue;
+    }
+    addToSchemaMap(schemaMap, property);
+    values.push(
+      `${name}: ` +
+        generateParameterTypeValue(getAccurateTypeName(property), name, schemaMap, path),
+    );
+  }
+  return values;
+}
+
+function getAccurateTypeName(schema: Schema) {
+  // For extensible enum, fallback to use the type
+  if (schema.typeName === "string" && schema.enum && schema.enum.length > 0) {
+    return schema.type;
+  }
+  return schema.typeName ?? schema.type;
+}
+
+function addToSchemaMap(schemaMap: Map<string, Schema>, schema: Schema) {
+  const type = getAccurateTypeName(schema);
+  if (!type) {
+    return;
+  }
+  if (!schemaMap.has(type) && !["string", "number", "boolean"].includes(schema.type)) {
+    schemaMap.set(type, schema);
+  }
+}

package/src/rlc-common/index.ts

@@ -1,43 +1,43 @@
 // 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 "./build-client-definitions.js";
+export * from "./build-client.js";
+export * from "./build-index-file.js";
+export * from "./build-is-unexpected-helper.js";
+export * from "./build-logger.js";
+export * from "./build-paginate-helper.js";
+export * from "./build-parameter-types.js";
+export * from "./build-polling-helper.js";
+export * from "./build-response-types.js";
+export * from "./build-samples.js";
+export * from "./build-schema-type.js";
+export * from "./build-serialize-helper.js";
+export * from "./build-top-level-index-file.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/package-util.js";
+export * from "./helpers/schema-helpers.js";
+export * from "./helpers/shortcut-methods.js";
+export * from "./helpers/value-generation-util.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-rollup-config.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";
+export * from "./transform-sample-groups.js";

package/src/rlc-common/metadata/build-package-file.ts

@@ -0,0 +1,242 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+import { Project, SourceFile } from "ts-morph";
+import { NameType, normalizeName } from "../helpers/name-utils.js";
+import { hasPollingOperations } from "../helpers/operation-helpers.js";
+import {
+  isAzureMonorepoPackage,
+  isAzurePackage,
+  isAzureStandalonePackage,
+} from "../helpers/package-util.js";
+import { getRelativePartFromSrcPath } from "../helpers/path-utils.js";
+import { RLCModel } from "../interfaces.js";
+import { buildAzureMonorepoPackage } from "./package-json/build-azure-monorepo-package.js";
+import { buildAzureStandalonePackage } from "./package-json/build-azure-standalone-package.js";
+import { buildFlavorlessPackage } from "./package-json/build-flavorless-package.js";
+import {
+  PackageCommonInfoConfig,
+  getTshyConfig,
+  resolveWarpExports,
+} from "./package-json/package-common.js";
+import { getPackageName } from "./utils.js";
+
+interface PackageFileOptions {
+  exports?: Record<string, any>;
+  dependencies?: Record<string, string>;
+  clientContextPaths?: string[];
+}
+
+export function buildPackageFile(
+  model: RLCModel,
+  { exports, dependencies, clientContextPaths }: PackageFileOptions = {},
+) {
+  const config: PackageCommonInfoConfig = {
+    description: getDescription(model),
+    moduleKind: model.options?.moduleKind ?? "esm",
+    name: getPackageName(model),
+    version: getPackageVersion(model),
+    withSamples: model.options?.generateSample === true,
+    withTests: model.options?.generateTest === true,
+    nameWithoutScope: model.options?.packageDetails?.nameWithoutScope,
+    exports,
+    azureArm: model.options?.azureArm,
+    isModularLibrary: model.options?.isModularLibrary ?? false,
+    azureSdkForJs: model.options?.azureSdkForJs,
+    generateReactNativeTarget: model.options?.generateReactNativeTarget,
+  };
+
+  let packageInfo: Record<string, any> = buildFlavorlessPackage(config);
+
+  const extendedConfig = {
+    ...config,
+    clientFilePaths: [getClientFilePath(model)],
+    hasLro: hasPollingOperations(model),
+    monorepoPackageDirectory: model.options?.azureOutputDirectory,
+    specSource: model.options?.sourceFrom ?? "TypeSpec",
+    dependencies,
+    clientContextPaths,
+  };
+
+  if (isAzureMonorepoPackage(model)) {
+    packageInfo = buildAzureMonorepoPackage(extendedConfig);
+  }
+
+  if (isAzureStandalonePackage(model)) {
+    packageInfo = buildAzureStandalonePackage(extendedConfig);
+  }
+
+  const project = new Project();
+  const filePath = "package.json";
+
+  if (!packageInfo) {
+    return;
+  }
+
+  const packageFile = project.createSourceFile(filePath, JSON.stringify(packageInfo, null, 2), {
+    overwrite: true,
+  });
+  return {
+    path: filePath,
+    content: packageFile.getFullText(),
+  };
+}
+
+/**
+ * Automatically updates the package.json for an existing Azure SDK package.
+ * - Migrates `@azure/core-client` → `@azure-rest/core-client` when found in dependencies.
+ * - Updates `@azure/core-lro` from `^2.x` to `^3.1.0`.
+ * - Adds LRO dependencies (`@azure/core-lro`, `@azure/abort-controller`) when the package has
+ *   polling operations (for non-monorepo Azure packages).
+ * - Updates exports (tshy or warp) when `exports` is provided.
+ * - Updates `//metadata.constantPaths` when `clientContextPaths` is provided.
+ */
+export function updatePackageFile(
+  model: RLCModel,
+  existingFilePathOrContent: string | Record<string, any>,
+  { exports, clientContextPaths }: PackageFileOptions = {},
+) {
+  const hasLro = hasPollingOperations(model);
+  const isAzure = isAzurePackage(model);
+  const needsLroUpdate = isAzure && hasLro;
+  const needsExportsUpdate = exports;
+  const needsConstantPathsUpdate = clientContextPaths && clientContextPaths.length > 0;
+  const needsPlatformImportsUpdate =
+    model.options?.azureSdkForJs && model.options?.moduleKind === "esm";
+
+  let packageInfo;
+  if (typeof existingFilePathOrContent === "string") {
+    let packageFile: SourceFile;
+    try {
+      const project = new Project();
+      packageFile = project.addSourceFileAtPath(existingFilePathOrContent);
+    } catch (_e) {
+      // If the file doesn't exist, we don't need to update it.
+      return;
+    }
+    packageInfo = JSON.parse(packageFile.getFullText());
+  } else {
+    packageInfo = existingFilePathOrContent;
+  }
+
+  // Migrate AutoRest-specific dependency names and versions to their TypeSpec equivalents.
+  const deps: Record<string, string> = { ...(packageInfo.dependencies ?? {}) };
+  let needsCoreClientUpdate = false;
+
+  // @azure/core-client is AutoRest-only; TypeSpec uses @azure-rest/core-client.
+  if ("@azure/core-client" in deps) {
+    needsCoreClientUpdate = true;
+  }
+
+  // Early return if nothing needs to be updated
+  if (
+    !needsLroUpdate &&
+    !needsExportsUpdate &&
+    !needsConstantPathsUpdate &&
+    !needsPlatformImportsUpdate &&
+    !needsCoreClientUpdate
+  ) {
+    return;
+  }
+
+  // Ensure warp packages have #platform/* imports for polyfill resolution.
+  // The `react-native` condition is only added when explicitly opted in via
+  // `generateReactNativeTarget`, matching the fresh-generation path in
+  // `getEsmEntrypointInformation` (packageCommon.ts).
+  if (needsPlatformImportsUpdate) {
+    const platformImports: Record<string, string> = {
+      browser: "./src/*-browser.mts",
+      default: "./src/*.ts",
+    };
+    if (model.options?.generateReactNativeTarget) {
+      // Insert `react-native` before `default` so Node's conditional
+      // resolution order matches the fresh-generation output.
+      packageInfo.imports = {
+        "#platform/*": {
+          browser: platformImports["browser"],
+          "react-native": "./src/*-react-native.mts",
+          default: platformImports["default"],
+        },
+      };
+    } else {
+      packageInfo.imports = {
+        "#platform/*": platformImports,
+      };
+    }
+  }
+
+  // Update exports based on build system (warp for monorepo, tshy for others)
+  if (needsExportsUpdate) {
+    if (model.options?.azureSdkForJs) {
+      // Warp: update resolved exports in package.json
+      packageInfo.exports = resolveWarpExports(exports, model.options?.generateReactNativeTarget);
+    } else if (packageInfo.tshy) {
+      // Tshy: update tshy.exports in package.json
+      const newTshy = getTshyConfig({
+        exports,
+        azureSdkForJs: model.options?.azureSdkForJs,
+        generateReactNativeTarget: model.options?.generateReactNativeTarget,
+      } as PackageCommonInfoConfig);
+      packageInfo.tshy["exports"] = newTshy["exports"];
+    }
+  }
+
+  // Update Core Client dependency
+  if (needsCoreClientUpdate) {
+    delete deps["@azure/core-client"];
+    if (!("@azure-rest/core-client" in deps)) {
+      deps["@azure-rest/core-client"] = "^2.3.1";
+    }
+    packageInfo.dependencies = deps;
+  }
+
+  // Update LRO dependencies for Azure packages
+  if (needsLroUpdate) {
+    packageInfo.dependencies = {
+      ...packageInfo.dependencies,
+      "@azure/core-lro": "^3.1.0",
+      "@azure/abort-controller": "^2.1.2",
+    };
+  }
+
+  // Update constantPaths metadata for Azure packages
+  if (needsConstantPathsUpdate && isAzure && packageInfo["//metadata"]) {
+    const metadata = packageInfo["//metadata"];
+    // Filter out existing userAgentInfo entries
+    const nonUserAgentPaths = (metadata.constantPaths || []).filter(
+      (item: any) => item.prefix !== "userAgentInfo",
+    );
+    // Add new userAgentInfo entries from clientContextPaths
+    const newUserAgentPaths = clientContextPaths!.map((path) => ({
+      path: path,
+      prefix: "userAgentInfo",
+    }));
+    metadata.constantPaths = [...nonUserAgentPaths, ...newUserAgentPaths];
+  }
+
+  return {
+    path: "package.json",
+    content: JSON.stringify(packageInfo, null, 2),
+  };
+}
+
+function getPackageVersion(model: RLCModel): string {
+  return model.options?.packageDetails?.version ?? "1.0.0-beta.1";
+}
+
+function getDescription(model: RLCModel): string {
+  const description = model.options?.packageDetails?.description;
+  if (!description) {
+    return `A generated SDK for ${model.libraryName}.`;
+  }
+  return description;
+}
+
+function getClientFilePath(model: RLCModel) {
+  const { srcPath } = model;
+  const sdkReletivePart = getRelativePartFromSrcPath(srcPath);
+  const clientFilename = normalizeName(model.libraryName, NameType.File);
+  return sdkReletivePart
+    ? `src/${sdkReletivePart}/${clientFilename}.ts`
+    : `src/${clientFilename}.ts`;
+}