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

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

@@ -1,138 +0,0 @@
-// 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 "./nameUtils.js";
-import { isObjectSchema } from "./schemaHelpers.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/helpers/packageUtil.ts

@@ -1,13 +0,0 @@
-import { RLCModel, RLCOptions } from "../interfaces.js";
-
-export function isAzurePackage(model: { options?: RLCOptions }): boolean {
-  return Boolean(model.options?.flavor === "azure");
-}
-
-export function isAzureMonorepoPackage(model: RLCModel): boolean {
-  return Boolean(model.options?.azureSdkForJs) && isAzurePackage(model);
-}
-
-export function isAzureStandalonePackage(model: RLCModel): boolean {
-  return isAzurePackage(model) && !model.options?.azureSdkForJs;
-}

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

@@ -1,10 +0,0 @@
-import * as path from "path";
-
-export function getRelativePartFromSrcPath(srcPath: string, isModularLibrary: boolean = false) {
-  const sep = srcPath.includes(path.sep + "src") ? path.sep : "/";
-  let relativePart = srcPath.substring(srcPath.indexOf(sep + "src") + 4);
-  if (isModularLibrary) {
-    relativePart = relativePart.substring(srcPath.indexOf(sep + "rest"), +5);
-  }
-  return relativePart.startsWith(sep) ? relativePart.substring(1) : relativePart;
-}

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/buildApiExtractorConfig.ts

@@ -1,64 +0,0 @@
-// Copyright (c) Microsoft Corporation.
-// Licensed under the MIT License.
-
-import { Project } from "ts-morph";
-import { RLCModel } from "../interfaces.js";
-
-export function buildApiExtractorConfig(model: RLCModel) {
-  const { packageDetails, isModularLibrary, generateTest, azureSdkForJs } = model.options || {};
-  const project = new Project();
-
-  let mainEntryPointFilePath = "dist/esm/index.d.ts";
-
-  if (model.options?.moduleKind === "cjs") {
-    mainEntryPointFilePath = `./types${generateTest || isModularLibrary ? "/src" : ""}/index.d.ts`;
-  }
-
-  const config = azureSdkForJs
-    ? {
-        extends: "../../../api-extractor-base.json",
-      }
-    : {
-        $schema:
-          "https://developer.microsoft.com/json-schemas/api-extractor/v7/api-extractor.schema.json",
-        mainEntryPointFilePath,
-        docModel: {
-          enabled: true,
-        },
-        apiReport: {
-          enabled: true,
-          reportFolder: "./review",
-        },
-        dtsRollup: {
-          enabled: true,
-          untrimmedFilePath: "",
-          publicTrimmedFilePath: `dist/${
-            packageDetails?.nameWithoutScope ?? packageDetails?.name
-          }.d.ts`,
-        },
-        messages: {
-          tsdocMessageReporting: {
-            default: {
-              logLevel: "none",
-            },
-          },
-          extractorMessageReporting: {
-            "ae-missing-release-tag": {
-              logLevel: "none",
-            },
-            "ae-unresolved-link": {
-              logLevel: "none",
-            },
-          },
-        },
-      };
-
-  const filePath = "api-extractor.json";
-  const configFile = project.createSourceFile(filePath, JSON.stringify(config), {
-    overwrite: true,
-  });
-  return {
-    path: filePath,
-    content: configFile.getFullText(),
-  };
-}

package/src/rlc-common/metadata/buildESLintConfig.ts

@@ -1,84 +0,0 @@
-// Copyright (c) Microsoft Corporation.
-// Licensed under the MIT License.
-
-import { Project } from "ts-morph";
-import { RLCModel } from "../interfaces.js";
-
-const eslintConfig = `import azsdkEslint from "@azure/eslint-plugin-azure-sdk";
-
-export default azsdkEslint.config([
-  {
-    rules: {
-      "@azure/azure-sdk/ts-modules-only-named": "warn",
-      "@azure/azure-sdk/ts-package-json-types": "warn",
-      "@azure/azure-sdk/ts-package-json-engine-is-present": "warn",
-      "tsdoc/syntax": "warn"
-    }
-  }
-]);
-`;
-
-const esLintConfigEsm = `import azsdkEslint from "@azure/eslint-plugin-azure-sdk";
-
-export default azsdkEslint.config([
-  {
-    rules: {
-      "@azure/azure-sdk/ts-modules-only-named": "warn",
-      "@azure/azure-sdk/ts-package-json-types": "warn",
-      "@azure/azure-sdk/ts-package-json-engine-is-present": "warn",
-      "@azure/azure-sdk/ts-package-json-files-required": "off",
-      "@azure/azure-sdk/ts-package-json-main-is-cjs": "off",
-      "tsdoc/syntax": "warn"
-    }
-  }
-]);
-`;
-
-const esLintConfigEsmAzureSdk = `import azsdkEslint from "@azure/eslint-plugin-azure-sdk";
-
-export default [
-  ...azsdkEslint.config([
-    {
-      rules: {
-        "@azure/azure-sdk/ts-modules-only-named": "warn",
-        "@azure/azure-sdk/ts-package-json-types": "warn",
-        "@azure/azure-sdk/ts-package-json-engine-is-present": "warn",
-        "@azure/azure-sdk/ts-package-json-files-required": "off",
-        "@azure/azure-sdk/ts-package-json-main-is-cjs": "off",
-        "tsdoc/syntax": "warn"
-      }
-    },
-  ]),
-  {
-    files: ["src/**/*.ts", "src/**/*.mts", "test/**/*.ts"],
-    languageOptions: {
-      parserOptions: {
-        projectService: false,
-        project: "./config/tsconfig.lint.json",
-      },
-    },
-  },
-];
-`;
-
-export function buildEsLintConfig(model: RLCModel) {
-  if (model.options?.flavor !== "azure") {
-    return;
-  }
-  const project = new Project();
-  const filePath = "eslint.config.mjs";
-
-  let template: string;
-  if (model.options?.moduleKind === "esm") {
-    template = model.options?.azureSdkForJs ? esLintConfigEsmAzureSdk : esLintConfigEsm;
-  } else {
-    template = eslintConfig;
-  }
-  const configFile = project.createSourceFile("eslint.config.mjs", template, {
-    overwrite: true,
-  });
-  return {
-    path: filePath,
-    content: configFile.getFullText(),
-  };
-}