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

package/src/rlc-common/build-response-types.ts

@@ -1,180 +0,0 @@
-// Copyright (c) Microsoft Corporation.
-// Licensed under the MIT License.
-
-import * as path from "path";
-import {
-  InterfaceDeclarationStructure,
-  OptionalKind,
-  Project,
-  PropertySignatureStructure,
-  StructureKind,
-} from "ts-morph";
-import { getImportSpecifier } from "./helpers/imports-util.js";
-import {
-  getImportModuleName,
-  getResponseBaseName,
-  getResponseTypeName,
-} from "./helpers/name-constructors.js";
-import { ResponseHeaderSchema, ResponseMetadata, RLCModel } from "./interfaces.js";
-
-let hasErrorResponse = false;
-export function buildResponseTypes(model: RLCModel) {
-  const project = new Project();
-  const srcPath = model.srcPath;
-  const filePath = path.join(srcPath, `responses.ts`);
-  hasErrorResponse = false;
-  const responsesFile = project.createSourceFile(filePath, undefined, {
-    overwrite: true,
-  });
-  // Set used to track down which models need to be imported
-  // Track if we need to import RawHttpHeaders
-  let hasHeaders = false;
-  if (!model.responses) {
-    return;
-  }
-  for (const operationResponse of model.responses) {
-    for (const response of operationResponse.responses) {
-      // Building the response type base name
-      const baseResponseName = getResponseBaseName(
-        operationResponse.operationGroup,
-        operationResponse.operationName,
-        response.statusCode,
-      );
-
-      // Build the response header
-      const headersInterface: InterfaceDeclarationStructure | undefined =
-        getResponseHeaderInterfaceDefinition(response, baseResponseName);
-      if (headersInterface) {
-        hasHeaders = true;
-        responsesFile.addInterface(headersInterface);
-      }
-
-      // Get the information to build the Response Interface
-      const responseTypeName = response.predefinedName ?? getResponseTypeName(baseResponseName);
-      const responseProperties = getResponseInterfaceProperties(response, headersInterface?.name);
-
-      const responseInterfaceDefinition: OptionalKind<InterfaceDeclarationStructure> = {
-        name: responseTypeName,
-        properties: responseProperties,
-        isExported: true,
-        extends: ["HttpResponse"],
-      };
-
-      // Only add a description if one was provided in the Swagger
-      // otherwise skip to avoid having empty TSDoc lines
-      if (response.description) {
-        responseInterfaceDefinition.docs = [{ description: response.description }];
-      }
-
-      // Add the response interface to the responses file
-      responsesFile.addInterface(responseInterfaceDefinition);
-    }
-  }
-
-  if (hasHeaders) {
-    responsesFile.addImportDeclarations([
-      {
-        isTypeOnly: true,
-        namedImports: ["RawHttpHeaders"],
-        moduleSpecifier: getImportSpecifier("restPipeline", model.importInfo.runtimeImports),
-      },
-    ]);
-  }
-  const namedImports = ["HttpResponse"];
-  if (hasErrorResponse) {
-    namedImports.push("ErrorResponse");
-  }
-  responsesFile.addImportDeclarations([
-    {
-      isTypeOnly: true,
-      namedImports,
-      moduleSpecifier: getImportSpecifier("restClient", model.importInfo.runtimeImports),
-    },
-  ]);
-
-  if ((model.importInfo.internalImports.response?.importsSet?.size ?? 0) > 0) {
-    const modelNamedImports = Array.from(
-      model.importInfo.internalImports.response!.importsSet!,
-    ).filter((modelName) => {
-      return !(modelName === "ErrorResponseOutput" && hasErrorResponse);
-    });
-    responsesFile.addImportDeclarations([
-      {
-        isTypeOnly: true,
-        namedImports: modelNamedImports,
-        moduleSpecifier: getImportModuleName(
-          {
-            cjsName: `./outputModels`,
-            esModulesName: `./outputModels.js`,
-          },
-          model,
-        ),
-      },
-    ]);
-  }
-  return { path: filePath, content: responsesFile.getFullText() };
-}
-
-function getResponseHeaderInterfaceDefinition(
-  response: ResponseMetadata,
-  baseName: string,
-): undefined | InterfaceDeclarationStructure {
-  // Check if there are any required headers
-  if (!response.headers) {
-    return;
-  }
-  const headersInterfaceName = `${baseName}Headers`;
-  return {
-    kind: StructureKind.Interface,
-    isExported: true,
-    name: headersInterfaceName,
-    properties: response?.headers.map((h: ResponseHeaderSchema) => {
-      const description = h.description;
-      return {
-        name: h.name,
-        ...(description && { docs: [{ description }] }),
-        type: h.type,
-        hasQuestionToken: !h.required,
-      };
-    }),
-  };
-}
-
-/**
- * Gets the properties that need to be part of the response interface
- */
-function getResponseInterfaceProperties(response: ResponseMetadata, headersInterfaceName?: string) {
-  const statusCode = response.statusCode;
-  const responseProperties: PropertySignatureStructure[] = [
-    {
-      name: "status",
-      type: statusCode === "default" ? `string` : `"${statusCode}"`,
-      kind: StructureKind.PropertySignature,
-    },
-  ];
-
-  if (response.body) {
-    const description = response.body.description;
-    let type = response.body.type;
-    if (response.body.type === "ErrorResponseOutput" && response.body.fromCore) {
-      type = "ErrorResponse";
-      hasErrorResponse = true;
-    }
-    responseProperties.push({
-      name: "body",
-      type,
-      kind: StructureKind.PropertySignature,
-      ...(description && { docs: [{ description }] }),
-    });
-  }
-
-  if (headersInterfaceName) {
-    responseProperties.push({
-      name: "headers",
-      type: `RawHttpHeaders & ${headersInterfaceName}`,
-      kind: StructureKind.PropertySignature,
-    });
-  }
-
-  return responseProperties;
-}

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 hbs from "handlebars";
-import * as path from "path";
-
-// 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 = path.join("samples-dev", `${sampleGroup.filename}.ts`);
-    sampleFiles.push({
-      path: filePath,
-      content: sampleGroupFileContents(sampleGroup),
-    });
-  }
-  return sampleFiles;
-}

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

@@ -1,89 +0,0 @@
-// Copyright (c) Microsoft Corporation.
-// Licensed under the MIT License.
-
-import * as path from "path";
-import { Project } from "ts-morph";
-import {
-  buildObjectAliases,
-  buildObjectInterfaces,
-  buildPolymorphicAliases,
-} from "./build-object-types.js";
-import { getImportSpecifier } from "./helpers/imports-util.js";
-import { getImportModuleName } from "./helpers/name-constructors.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();
-  let filePath = path.join(srcPath, `models.ts`);
-  const inputModelFile = generateModelFiles(model, project, filePath, [SchemaContext.Input]);
-  filePath = path.join(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")) {
-      const platformTypesModuleSpecifier = model.options?.azureSdkForJs
-        ? "#platform/platform-types"
-        : getImportModuleName(
-            {
-              cjsName: `./platform-types`,
-              esModulesName: `./platform-types.js`,
-            },
-            model,
-          );
-      modelsFile.addImportDeclarations([
-        {
-          isTypeOnly: true,
-          namedImports: ["NodeReadableStream"],
-          moduleSpecifier: platformTypesModuleSpecifier,
-        },
-      ]);
-    }
-    return { path: filePath, content: modelsFile.getFullText() };
-  }
-  return undefined;
-}

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

@@ -1,49 +0,0 @@
-import * as path from "path";
-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: path.join(srcPath, "serializeHelper.ts"),
-      content: readmeFileContents({}),
-    };
-  }
-  return undefined;
-}

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

@@ -1,58 +0,0 @@
-// Copyright (c) Microsoft Corporation.
-// Licensed under the MIT License.
-
-import * as path from "path";
-import { Project } from "ts-morph";
-import { getImportModuleName } from "./helpers/name-constructors.js";
-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();
-  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: getImportModuleName(
-          {
-            cjsName: `${item[0]}`,
-            esModulesName: `${item[0]}/index.js`,
-          },
-          model,
-        ),
-      });
-      allModules.push(item[1]);
-    });
-    indexFile.addExportDeclaration({
-      namedExports: [...allModules],
-    });
-    const content = indexFile.getFullText();
-    const filePath = path.join(
-      srcPath.substring(0, srcPath.lastIndexOf("src") + 4),
-      model.options.isModularLibrary ? "rest" : "",
-      `index.ts`,
-    );
-    return { path: filePath, content };
-  }
-  return undefined;
-}

package/src/rlc-common/helpers/package-util.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/path-utils.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/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;
-}