@azure-tools/typespec-ts 0.55.0-dev.7 → 0.55.0-dev.9

package/src/rlc-common/build-samples.ts

@@ -1,32 +0,0 @@
-// Copyright (c) Microsoft Corporation.
-// Licensed under the MIT License.
-
-import { File as RLCFile, RLCModel, RLCSampleGroup } from "./interfaces.js";
-import { sampleTemplate } from "./static/sample-template.js";
-// eslint-disable-next-line @typescript-eslint/ban-ts-comment
-// @ts-ignore: to fix the handlebars issue
-import { joinPaths } from "@typespec/compiler";
-import hbs from "handlebars";
-
-// Build sample files for the model based on the sample groups
-export function buildSamples(model: RLCModel) {
-  if (!model.options || !model.options.packageDetails) {
-    return;
-  }
-  const sampleGroups: RLCSampleGroup[] | undefined = model.sampleGroups;
-  if (!sampleGroups || sampleGroups.length === 0) {
-    return;
-  }
-  const sampleFiles: RLCFile[] = [];
-  for (const sampleGroup of sampleGroups) {
-    const sampleGroupFileContents = hbs.compile(sampleTemplate, {
-      noEscape: true,
-    });
-    const filePath = joinPaths("samples-dev", `${sampleGroup.filename}.ts`);
-    sampleFiles.push({
-      path: filePath,
-      content: sampleGroupFileContents(sampleGroup),
-    });
-  }
-  return sampleFiles;
-}

package/src/rlc-common/build-schema-type.ts

@@ -1,79 +0,0 @@
-// Copyright (c) Microsoft Corporation.
-// Licensed under the MIT License.
-
-import { joinPaths } from "@typespec/compiler";
-import { Project } from "ts-morph";
-import {
-  buildObjectAliases,
-  buildObjectInterfaces,
-  buildPolymorphicAliases,
-} from "./build-object-types.js";
-import { getImportSpecifier } from "./helpers/imports-util.js";
-import { RLCModel, SchemaContext } from "./interfaces.js";
-
-/**
- * Generates types to represent schema definitions in the swagger
- */
-export function buildSchemaTypes(model: RLCModel) {
-  const { srcPath } = model;
-  const project = new Project({ useInMemoryFileSystem: true });
-  let filePath = joinPaths(srcPath, `models.ts`);
-  const inputModelFile = generateModelFiles(model, project, filePath, [SchemaContext.Input]);
-  filePath = joinPaths(srcPath, `outputModels.ts`);
-  const outputModelFile = generateModelFiles(model, project, filePath, [
-    SchemaContext.Output,
-    SchemaContext.Exception,
-  ]);
-  return { inputModelFile, outputModelFile };
-}
-
-export function generateModelFiles(
-  model: RLCModel,
-  project: Project,
-  filePath: string,
-  schemaContext: SchemaContext[],
-) {
-  // Track models that need to be imported
-  const importedModels = new Set<string>();
-  const objectsDefinitions = buildObjectInterfaces(model, importedModels, schemaContext);
-
-  const objectTypeAliases = buildPolymorphicAliases(model, schemaContext);
-
-  const objectAliases = buildObjectAliases(model, importedModels, schemaContext);
-
-  if (objectTypeAliases.length || objectsDefinitions.length || objectAliases.length) {
-    const modelsFile = project.createSourceFile(filePath, undefined, {
-      overwrite: true,
-    });
-
-    modelsFile.addInterfaces(objectsDefinitions);
-    modelsFile.addTypeAliases(objectTypeAliases);
-    modelsFile.addTypeAliases(objectAliases);
-    if (importedModels.size > 0) {
-      modelsFile.addImportDeclarations([
-        {
-          isTypeOnly: true,
-          namedImports: [...Array.from(importedModels || [])],
-          moduleSpecifier: getImportSpecifier("restClient", model.importInfo.runtimeImports),
-        },
-      ]);
-    }
-    // Add NodeReadableStream import if binary types are used in models.
-    // platform-types.ts is generated directly under src/ (no static-helpers/
-    // subdirectory) to match the RLC design where all output lives in src/.
-    // The platform-types static helper resolves NodeReadableStream to
-    // NodeJS.ReadableStream on Node and `never` on browser/react-native, so the
-    // union arm drops out naturally in non-Node builds.
-    if (modelsFile.getFullText().includes("NodeReadableStream")) {
-      modelsFile.addImportDeclarations([
-        {
-          isTypeOnly: true,
-          namedImports: ["NodeReadableStream"],
-          moduleSpecifier: "#platform/platform-types",
-        },
-      ]);
-    }
-    return { path: filePath, content: modelsFile.getFullText() };
-  }
-  return undefined;
-}

package/src/rlc-common/build-serialize-helper.ts

@@ -1,49 +0,0 @@
-import { joinPaths } from "@typespec/compiler";
-import { RLCModel } from "./interfaces.js";
-// eslint-disable-next-line @typescript-eslint/ban-ts-comment
-// @ts-ignore: to fix the handlebars issue
-import hbs from "handlebars";
-import {
-  hasCsvCollection,
-  hasMultiCollection,
-  hasPipeCollection,
-  hasSsvCollection,
-  hasTsvCollection,
-} from "./helpers/operation-helpers.js";
-import {
-  buildCsvCollectionContent,
-  buildMultiCollectionContent,
-  buildPipeCollectionContent,
-  buildSsvCollectionContent,
-  buildTsvCollectionContent,
-} from "./static/serialize-helper.js";
-
-export function buildSerializeHelper(model: RLCModel) {
-  let serializeHelperContent = "";
-  if (hasMultiCollection(model)) {
-    serializeHelperContent += "\n" + buildMultiCollectionContent;
-  }
-  if (hasPipeCollection(model)) {
-    serializeHelperContent += "\n" + buildPipeCollectionContent;
-  }
-  if (hasSsvCollection(model)) {
-    serializeHelperContent += "\n" + buildSsvCollectionContent;
-  }
-  if (hasTsvCollection(model)) {
-    serializeHelperContent += "\n" + buildTsvCollectionContent;
-  }
-  if (hasCsvCollection(model)) {
-    serializeHelperContent += "\n" + buildCsvCollectionContent;
-  }
-  if (serializeHelperContent !== "") {
-    const readmeFileContents = hbs.compile(serializeHelperContent, {
-      noEscape: true,
-    });
-    const { srcPath } = model;
-    return {
-      path: joinPaths(srcPath, "serializeHelper.ts"),
-      content: readmeFileContents({}),
-    };
-  }
-  return undefined;
-}

package/src/rlc-common/build-top-level-index-file.ts

@@ -1,51 +0,0 @@
-// Copyright (c) Microsoft Corporation.
-// Licensed under the MIT License.
-
-import { joinPaths } from "@typespec/compiler";
-import { Project } from "ts-morph";
-import { NameType, normalizeName } from "./helpers/name-utils.js";
-import { getRelativePartFromSrcPath } from "./helpers/path-utils.js";
-import { RLCModel } from "./interfaces.js";
-
-const batchOutputFolder: [string, string, string][] = [];
-
-export function buildTopLevelIndex(model: RLCModel) {
-  if (!model.options) {
-    return undefined;
-  }
-  const project = new Project({ useInMemoryFileSystem: true });
-  const { srcPath } = model;
-  const { multiClient } = model.options;
-  const batch = model.options.batch;
-  if (srcPath) {
-    const clientName = model.libraryName;
-    const moduleName = normalizeName(clientName, NameType.File);
-    const relativePath = "./" + getRelativePartFromSrcPath(srcPath, model.options.isModularLibrary);
-    batchOutputFolder.push([relativePath, clientName, moduleName]);
-  }
-  if (multiClient && batch && batch.length > 1 && batchOutputFolder.length === batch.length) {
-    const indexFile = project.createSourceFile("index.ts", undefined, {
-      overwrite: true,
-    });
-    const allModules: string[] = [];
-    batchOutputFolder.forEach((item) => {
-      indexFile.addImportDeclaration({
-        isTypeOnly: true,
-        namespaceImport: item[1],
-        moduleSpecifier: `${item[0]}/index.js`,
-      });
-      allModules.push(item[1]);
-    });
-    indexFile.addExportDeclaration({
-      namedExports: [...allModules],
-    });
-    const content = indexFile.getFullText();
-    const filePath = joinPaths(
-      srcPath.substring(0, srcPath.lastIndexOf("src") + 4),
-      model.options.isModularLibrary ? "rest" : "",
-      `index.ts`,
-    );
-    return { path: filePath, content };
-  }
-  return undefined;
-}

package/src/rlc-common/helpers/path-utils.ts

@@ -1,8 +0,0 @@
-export function getRelativePartFromSrcPath(srcPath: string, isModularLibrary: boolean = false) {
-  const 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/shortcut-methods.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 "./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

@@ -1,234 +0,0 @@
-// 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);
-  }
-}