@azure-tools/typespec-ts 0.53.3 → 0.54.0

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

@@ -0,0 +1,67 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+import {
+  OptionalKind,
+  MethodSignatureStructure,
+  InterfaceDeclarationStructure
+} from "ts-morph";
+import { PathMetadata, Paths } from "../interfaces.js";
+import { buildMethodDefinitions } from "./operationHelpers.js";
+import { NameType, normalizeName } from "./nameUtils.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/typeUtil.ts

@@ -0,0 +1,173 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+import { Schema } from "../interfaces.js";
+
+export function isRecord(type: string) {
+  return /^Record<([a-zA-Z]+),(\s*)(?<type>.+)>$/.test(type);
+}
+
+export function getRecordType(type: string) {
+  return /^Record<([a-zA-Z]+),(\s*)(?<type>.+)>$/.exec(type)?.groups?.["type"];
+}
+
+export function isArray(type: string) {
+  return isArrayObject(type) || isNativeArray(type);
+}
+
+export function isArrayObject(type: string) {
+  return /(^Array<(.+)>$)/g.test(type);
+}
+
+export function getArrayObjectType(type: string) {
+  return /^Array<(?<type>.+)>$/g.exec(type)?.groups?.["type"];
+}
+
+export function isNativeArray(type: string) {
+  return /(^.+)\[\]$/g.test(type);
+}
+
+export function getNativeArrayType(type: string) {
+  return /(?<type>.+)\[\]/g.exec(type)?.groups?.["type"];
+}
+
+export function isUnion(type: string) {
+  const members = type.split("|").map((m) => m.trim());
+  return members.length > 1 && !isStringLiteral(type) && !isRecord(type);
+}
+
+export function getUnionType(type: string) {
+  const firstMember = type.split("|").map((m) => m.trim())[0];
+  if (firstMember === undefined) {
+    return type;
+  }
+  return leaveBracket(firstMember);
+}
+
+export function leaveBracket(type: string) {
+  if (!type || type.length < 2) {
+    return type;
+  } else if (type.startsWith("(") && type.endsWith(")")) {
+    return type.slice(1, type.length - 1);
+  }
+  return type;
+}
+
+export function leaveStringQuotes(str: string) {
+  if (isStringLiteral(str)) {
+    return str.slice(1, str.length - 1);
+  }
+  return str;
+}
+
+export enum TypeScriptType {
+  string,
+  date,
+  number,
+  boolean,
+  constant,
+  record,
+  array,
+  object,
+  union,
+  unknown,
+  enum
+}
+
+export function toTypeScriptTypeFromSchema(
+  schema: Schema
+): TypeScriptType | undefined {
+  schema.type = schema.type.trim();
+  if (
+    schema.type === "string" &&
+    schema.typeName === "Date | string" &&
+    schema.outputTypeName === "string"
+  ) {
+    return TypeScriptType.date;
+  } else if (schema.enum && schema.enum.length > 0) {
+    if (schema.type === "union" || schema.type === "object") {
+      // Include both union and named union
+      return TypeScriptType.union;
+    } else {
+      // Include both extensible and fixed enum
+      return TypeScriptType.enum;
+    }
+  } else if (
+    schema.isConstant === true ||
+    isConstant(schema.typeName ?? schema.type)
+  ) {
+    return TypeScriptType.constant;
+  } else if (schema.type === "number") {
+    return TypeScriptType.number;
+  } else if (schema.type === "boolean") {
+    return TypeScriptType.boolean;
+  } else if (schema.type === "string") {
+    return TypeScriptType.string;
+  } else if (schema.type === "unknown") {
+    return TypeScriptType.unknown;
+  } else if (schema.type === "dictionary") {
+    return TypeScriptType.record;
+  } else if (schema.type === "array") {
+    return TypeScriptType.array;
+  } else if (schema.type === "object") {
+    return TypeScriptType.object;
+  }
+  return undefined;
+}
+
+export function toTypeScriptTypeFromName(
+  typeName: string
+): TypeScriptType | undefined {
+  typeName = typeName.trim();
+  if (typeName === "Date") {
+    return TypeScriptType.date;
+  } else if (typeName === "string") {
+    return TypeScriptType.string;
+  } else if (typeName === "number") {
+    return TypeScriptType.number;
+  } else if (typeName === "boolean") {
+    return TypeScriptType.boolean;
+  } else if (typeName === "unknown") {
+    return TypeScriptType.unknown;
+  } else if (isConstant(typeName)) {
+    return TypeScriptType.constant;
+  } else if (isRecord(typeName)) {
+    return TypeScriptType.record;
+  } else if (isArray(typeName)) {
+    return TypeScriptType.array;
+  } else if (isUnion(typeName)) {
+    return TypeScriptType.union;
+  }
+  return undefined;
+}
+
+export function isConstant(typeName: string) {
+  return (
+    ["never", "null"].includes(typeName) ||
+    isBoolLiteral(typeName) ||
+    isNumericLiteral(typeName) ||
+    isStringLiteral(typeName)
+  );
+}
+
+export function isNumericLiteral(str: string) {
+  if (typeof str !== "string") return false;
+  return !isNaN(Number(str)) && !isNaN(parseFloat(str));
+}
+
+export function isBoolLiteral(str: string) {
+  return str === "true" || str === "false";
+}
+
+export function isStringLiteral(type: string) {
+  if (type.length < 2) {
+    return false;
+  }
+  const first = type[0];
+  const lastPos = type.length - 1;
+  return (
+    first === type[lastPos] &&
+    (first === '"' || first === "'") &&
+    type.indexOf(first, 1) === lastPos
+  );
+}

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

@@ -0,0 +1,257 @@
+// 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/index.ts

@@ -0,0 +1,43 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+export * from "./interfaces.js";
+export * from "./buildClientDefinitions.js";
+export * from "./buildSchemaType.js";
+export * from "./buildClient.js";
+export * from "./helpers/nameConstructors.js";
+export * from "./buildResponseTypes.js";
+export * from "./helpers/shortcutMethods.js";
+export * from "./helpers/nameUtils.js";
+export * from "./helpers/operationHelpers.js";
+export * from "./helpers/valueGenerationUtil.js";
+export * from "./helpers/schemaHelpers.js";
+export * from "./buildParameterTypes.js";
+export * from "./buildIsUnexpectedHelper.js";
+export * from "./buildTopLevelIndexFile.js";
+export * from "./buildIndexFile.js";
+export * from "./buildPaginateHelper.js";
+export * from "./buildPollingHelper.js";
+export * from "./test/buildKarmaConfig.js";
+export * from "./test/buildRecordedClient.js";
+export * from "./test/buildSampleTest.js";
+export * from "./test/buildSnippets.js";
+export * from "./metadata/buildReadmeFile.js";
+export * from "./metadata/buildApiExtractorConfig.js";
+export * from "./metadata/buildPackageFile.js";
+export * from "./metadata/buildRollupConfig.js";
+export * from "./metadata/buildTsConfig.js";
+export * from "./metadata/buildWarpConfig.js";
+export * from "./metadata/buildESLintConfig.js";
+export * from "./metadata/buildLicenseFile.js";
+export * from "./metadata/buildChangelogFile.js";
+export * from "./metadata/buildVitestConfig.js";
+export * from "./metadata/buildSampleEnvFile.js";
+export * from "./buildSerializeHelper.js";
+export * from "./helpers/apiVersionUtil.js";
+export * from "./buildLogger.js";
+export * from "./buildSamples.js";
+export * from "./transformSampleGroups.js";
+export * from "./helpers/importsUtil.js";
+export * from "./metadata/buildTestConfig.js";
+export * from "./helpers/packageUtil.js";