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

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

@@ -1,58 +0,0 @@
-// 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 "./nameUtils.js";
-import { buildMethodDefinitions } from "./operationHelpers.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/valueGenerationUtil.ts

@@ -1,234 +0,0 @@
-// Copyright (c) Microsoft Corporation.
-// Licensed under the MIT License.
-
-import { getImmediateParentsNames } from "../buildObjectTypes.js";
-import {
-  ArraySchema,
-  DictionarySchema,
-  ObjectSchema,
-  Schema,
-  SchemaContext,
-} from "../interfaces.js";
-import {
-  TypeScriptType,
-  getArrayObjectType,
-  getNativeArrayType,
-  getRecordType,
-  getUnionType,
-  isArrayObject,
-  isNativeArray,
-  leaveBracket,
-  leaveStringQuotes,
-  toTypeScriptTypeFromName,
-  toTypeScriptTypeFromSchema,
-} from "./typeUtil.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/metadata/buildPackageFile.ts

@@ -1,242 +0,0 @@
-// Copyright (c) Microsoft Corporation.
-// Licensed under the MIT License.
-
-import { Project, SourceFile } from "ts-morph";
-import { NameType, normalizeName } from "../helpers/nameUtils.js";
-import { hasPollingOperations } from "../helpers/operationHelpers.js";
-import {
-  isAzureMonorepoPackage,
-  isAzurePackage,
-  isAzureStandalonePackage,
-} from "../helpers/packageUtil.js";
-import { getRelativePartFromSrcPath } from "../helpers/pathUtils.js";
-import { RLCModel } from "../interfaces.js";
-import { buildAzureMonorepoPackage } from "./packageJson/buildAzureMonorepoPackage.js";
-import { buildAzureStandalonePackage } from "./packageJson/buildAzureStandalonePackage.js";
-import { buildFlavorlessPackage } from "./packageJson/buildFlavorlessPackage.js";
-import {
-  PackageCommonInfoConfig,
-  getTshyConfig,
-  resolveWarpExports,
-} from "./packageJson/packageCommon.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`;
-}