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

package/src/modular/build-restore-poller.ts

@@ -0,0 +1,242 @@
+import { SdkClientType, SdkServiceOperation } from "@azure-tools/typespec-client-generator-core";
+import { joinPaths } from "@typespec/compiler";
+import { SourceFile } from "ts-morph";
+import { useContext } from "../context-manager.js";
+import { useDependencies } from "../framework/hooks/use-dependencies.js";
+import { resolveReference } from "../framework/reference.js";
+import { NameType, normalizeName } from "../rlc-common/index.js";
+import { getModularClientOptions } from "../utils/client-utils.js";
+import { SdkContext } from "../utils/interfaces.js";
+import { getMethodHierarchiesMap } from "../utils/operation-util.js";
+import { buildLroDeserDetailMap } from "./build-operations.js";
+import { AzurePollingDependencies } from "./external-dependencies.js";
+import { getClassicalClientName } from "./helpers/naming-helpers.js";
+import { isLroOnlyOperation } from "./helpers/operation-helpers.js";
+import { ModularEmitterOptions } from "./interfaces.js";
+import { PollingHelpers } from "./static-helpers-metadata.js";
+
+export function buildRestorePoller(
+  context: SdkContext,
+  clientMap: [string[], SdkClientType<SdkServiceOperation>],
+  emitterOptions: ModularEmitterOptions,
+) {
+  const project = useContext("outputProject");
+  const [_, client] = clientMap;
+  const dependencies = useDependencies();
+  const { subfolder } = getModularClientOptions(clientMap);
+  const methodMap = getMethodHierarchiesMap(context, client);
+  const hasLro = Array.from(methodMap.values()).some((operations) => {
+    return operations.some(isLroOnlyOperation);
+  });
+  if (!hasLro) {
+    return;
+  }
+  const srcPath = emitterOptions.modularOptions.sourceRoot;
+  const filePath = joinPaths(
+    `${srcPath}/${subfolder && subfolder !== "" ? subfolder + "/" : ""}restorePollerHelpers.ts`,
+  );
+  const restorePollerFile = project.createSourceFile(filePath, undefined, {
+    overwrite: true,
+  });
+
+  const clientNames = importClassicalClient(client, restorePollerFile);
+  const deserializeMap = importDeserializeHelpers(context, client, restorePollerFile);
+  const pathUncheckedReference = resolveReference(dependencies.PathUncheckedResponse);
+  const pollerLikeReference = resolveReference(AzurePollingDependencies.PollerLike);
+  const operationStateReference = resolveReference(AzurePollingDependencies.OperationState);
+  const operationOptionsReference = resolveReference(dependencies.OperationOptions);
+  const deserializeStateReference = resolveReference(AzurePollingDependencies.DeserializeState);
+  const restorePollerHelperContent = `
+    export interface RestorePollerOptions<
+      TResult,
+      TResponse extends ${pathUncheckedReference} = ${pathUncheckedReference}
+    > extends ${operationOptionsReference} {
+      /** Delay to wait until next poll, in milliseconds. */
+      updateIntervalInMs?: number;
+      /**
+       * The signal which can be used to abort requests.
+      */
+      abortSignal?: ${resolveReference(dependencies.AbortSignalLike)};
+      /** Deserialization function for raw response body */
+      processResponseBody?: (result: TResponse) => Promise<TResult>;
+    }
+    
+    /**
+     * Creates a poller from the serialized state of another poller. This can be
+     * useful when you want to create pollers on a different host or a poller
+     * needs to be constructed after the original one is not in scope.
+     */
+    export function restorePoller<TResponse extends ${pathUncheckedReference}, TResult>(
+      client: ${clientNames.join(" | ")},
+      serializedState: string,
+      sourceOperation: (
+        ...args: any[]
+      ) => ${pollerLikeReference}<${operationStateReference}<TResult>, TResult>,
+      options?: RestorePollerOptions<TResult>
+    ): ${pollerLikeReference}<${operationStateReference}<TResult>, TResult> {
+      const pollerConfig = ${deserializeStateReference}(serializedState).config;
+      const { initialRequestUrl, requestMethod, metadata } = pollerConfig;
+      if (!initialRequestUrl || !requestMethod) {
+        throw new Error(
+          \`Invalid serialized state: \${serializedState} for sourceOperation \${sourceOperation?.name}\`
+        );
+      }
+      const resourceLocationConfig = metadata?.["resourceLocationConfig"] as
+        | ${resolveReference(AzurePollingDependencies.ResourceLocationConfig)}
+        | undefined;
+      const { deserializer, expectedStatuses = [] } =
+        getDeserializationHelper(initialRequestUrl, requestMethod) ?? {};
+      const deserializeHelper = options?.processResponseBody ?? deserializer;
+      if (!deserializeHelper) {
+        throw new Error(
+          \`Please ensure the operation is in this client! We can't find its deserializeHelper for \${sourceOperation?.name}.\`
+        );
+      }
+      const apiVersion = getApiVersionFromUrl(initialRequestUrl);
+      return ${resolveReference(PollingHelpers.GetLongRunningPoller)}(
+        (client as any)["_client"] ?? client,
+        deserializeHelper as (result: TResponse) => Promise<TResult>,
+        expectedStatuses,
+        {
+          updateIntervalInMs: options?.updateIntervalInMs,
+          abortSignal: options?.abortSignal,
+          resourceLocationConfig,
+          restoreFrom: serializedState,
+          initialRequestUrl,
+          apiVersion,
+        }
+      );
+    }
+    
+    interface DeserializationHelper {
+      deserializer: (result: PathUncheckedResponse) => Promise<any>;
+      expectedStatuses: string[];
+    }
+
+    const deserializeMap: Record<string, DeserializationHelper> = {
+      ${deserializeMap.join(",\n")}
+    };
+
+    function getDeserializationHelper(
+      urlStr: string,
+      method: string
+    ): DeserializationHelper | undefined {
+      const path = new URL(urlStr).pathname;
+      const pathParts = path.split("/");
+    
+      // Traverse list to match the longest candidate
+      // matchedLen: the length of candidate path
+      // matchedValue: the matched status code array
+      let matchedLen = -1,
+        matchedValue: DeserializationHelper | undefined;
+    
+      // Iterate the responseMap to find a match
+      for (const [key, value] of Object.entries(deserializeMap)) {
+        // Extracting the path from the map key which is in format
+        // GET /path/foo
+        if (!key.startsWith(method)) {
+          continue;
+        }
+        const candidatePath = getPathFromMapKey(key);
+        // Get each part of the url path
+        const candidateParts = candidatePath.split("/");
+    
+        // track if we have found a match to return the values found.
+        let found = true;
+        for (
+          let i = candidateParts.length - 1, j = pathParts.length - 1;
+          i >= 1 && j >= 1;
+          i--, j--
+        ) {
+          if (
+            candidateParts[i]?.startsWith("{") &&
+            candidateParts[i]?.indexOf("}") !== -1
+          ) {
+            const start = candidateParts[i]!.indexOf("}") + 1,
+              end = candidateParts[i]?.length;
+            // If the current part of the candidate is a "template" part
+            // Try to use the suffix of pattern to match the path
+            // {guid} ==> $
+            // {guid}:export ==> :export$
+            const isMatched = new RegExp(
+              \`\${candidateParts[i]?.slice(start, end)}\`
+            ).test(pathParts[j] || "");
+    
+            if (!isMatched) {
+              found = false;
+              break;
+            }
+            continue;
+          }
+    
+          // If the candidate part is not a template and
+          // the parts don't match mark the candidate as not found
+          // to move on with the next candidate path.
+          if (candidateParts[i] !== pathParts[j]) {
+            found = false;
+            break;
+          }
+        }
+    
+        // We finished evaluating the current candidate parts
+        // Update the matched value if and only if we found the longer pattern
+        if (found && candidatePath.length > matchedLen) {
+          matchedLen = candidatePath.length;
+          matchedValue = value;
+        }
+      }
+    
+      return matchedValue;
+    }
+    
+    function getPathFromMapKey(mapKey: string): string {
+      const pathStart = mapKey.indexOf("/");
+      return mapKey.slice(pathStart);
+    }
+    
+    function getApiVersionFromUrl(urlStr: string): string | undefined {
+      const url = new URL(urlStr);
+      return url.searchParams.get("api-version") ?? undefined;
+    }
+  `;
+  restorePollerFile.addStatements(restorePollerHelperContent);
+}
+
+function importDeserializeHelpers(
+  context: SdkContext,
+  client: SdkClientType<SdkServiceOperation>,
+  sourceFile: SourceFile,
+) {
+  const deserializeDetails = buildLroDeserDetailMap(context, client);
+  const deserializeMap: string[] = [];
+  for (const [key, value] of deserializeDetails.entries()) {
+    sourceFile.addImportDeclaration({
+      namedImports: value.map((detail) =>
+        detail.renamedDeserName
+          ? `${detail.deserName} as ${detail.renamedDeserName}`
+          : detail.deserName,
+      ),
+      moduleSpecifier: key,
+    });
+    value.forEach((detail) => {
+      deserializeMap.push(
+        `"${detail.path}": { deserializer: ${
+          detail.renamedDeserName ?? detail.deserName
+        }, expectedStatuses: ${detail.expectedStatusesExpression} }`,
+      );
+    });
+  }
+  return deserializeMap;
+}
+
+function importClassicalClient(
+  client: SdkClientType<SdkServiceOperation>,
+  sourceFile: SourceFile,
+): string[] {
+  const classicalClientName = `${getClassicalClientName(client)}`;
+  sourceFile.addImportDeclaration({
+    namedImports: [`${classicalClientName}`],
+    moduleSpecifier: `./${normalizeName(classicalClientName, NameType.File)}.js`,
+  });
+  return [classicalClientName];
+}

package/src/modular/build-root-index.ts

@@ -0,0 +1,403 @@
+import { SdkClientType, SdkServiceOperation } from "@azure-tools/typespec-client-generator-core";
+import { joinPaths, NoTarget } from "@typespec/compiler";
+import { Project, SourceFile } from "ts-morph";
+import { useContext } from "../context-manager.js";
+import { resolveReference } from "../framework/reference.js";
+import { reportDiagnostic } from "../lib.js";
+import { NameType, normalizeName } from "../rlc-common/index.js";
+import { getModularClientOptions } from "../utils/client-utils.js";
+import { SdkContext } from "../utils/interfaces.js";
+import { getMethodHierarchiesMap } from "../utils/operation-util.js";
+import { partitionAndEmitExports } from "./build-subpath-index.js";
+import { getClassicalClientName } from "./helpers/naming-helpers.js";
+import { isLroOnlyOperation } from "./helpers/operation-helpers.js";
+import { ModularEmitterOptions } from "./interfaces.js";
+import {
+  CloudSettingHelpers,
+  MultipartHelpers,
+  PagingHelpers,
+  PlatformTypeHelpers,
+} from "./static-helpers-metadata.js";
+
+export function buildRootIndex(
+  context: SdkContext,
+  emitterOptions: ModularEmitterOptions,
+  rootIndexFile: SourceFile,
+  clientMap?: [string[], SdkClientType<SdkServiceOperation>],
+) {
+  if (!clientMap) {
+    // we still need to export the models if no client is provided
+    exportModels(emitterOptions, rootIndexFile);
+    exportRestErrorTypes(rootIndexFile);
+    return;
+  }
+  const project = useContext("outputProject");
+  const [_, client] = clientMap;
+  const srcPath = emitterOptions.modularOptions.sourceRoot;
+  const { subfolder } = getModularClientOptions(clientMap);
+  const clientName = `${getClassicalClientName(client)}`;
+  const clientFile = project.getSourceFile(
+    `${srcPath}/${subfolder && subfolder !== "" ? subfolder + "/" : ""}${normalizeName(
+      clientName,
+      NameType.File,
+    )}.ts`,
+  );
+
+  if (!clientFile) {
+    reportDiagnostic(context.program, {
+      code: "client-file-not-found",
+      format: {
+        filePath: `${srcPath}/${normalizeName(clientName, NameType.File)}.ts`,
+      },
+      target: NoTarget,
+    });
+    return; // Skip exporting this client but continue with others
+  }
+
+  exportClassicalClient(client, rootIndexFile, subfolder ?? "");
+  exportSimplePollerLike(context, clientMap, rootIndexFile, project, srcPath, subfolder);
+  exportRestoreHelpers(rootIndexFile, project, srcPath, clientName, subfolder, true);
+  exportModels(emitterOptions, rootIndexFile, clientName);
+  exportModules(rootIndexFile, project, srcPath, clientName, "api", {
+    subfolder,
+    interfaceOnly: true,
+    isTopLevel: true,
+  });
+  exportModules(rootIndexFile, project, srcPath, clientName, "classic", {
+    subfolder,
+    isTopLevel: true,
+  });
+
+  exportPagingTypes(context, rootIndexFile);
+  exportFileContentsType(context, rootIndexFile);
+  exportAzureCloudTypes(context, rootIndexFile);
+  exportRestErrorTypes(rootIndexFile);
+}
+
+function exportModels(
+  emitterOptions: ModularEmitterOptions,
+  rootIndexFile: SourceFile,
+  clientName: string = "",
+) {
+  // export models index file if not exists
+  const project = useContext("outputProject");
+  const srcPath = emitterOptions.modularOptions.sourceRoot;
+  const modelsExportsIndex = rootIndexFile.getExportDeclarations()?.find((i) => {
+    return i.getModuleSpecifierValue()?.startsWith(`./models/`);
+  });
+  if (!modelsExportsIndex) {
+    exportModules(rootIndexFile, project, srcPath, clientName, "models", {
+      isTopLevel: true,
+      recursive: true,
+    });
+  }
+}
+
+function exportAzureCloudTypes(context: SdkContext, rootIndexFile: SourceFile) {
+  if (context.arm) {
+    // AzureClouds is an enum (runtime value), AzureSupportedClouds is a type alias
+    addExportsToRootIndexFile(rootIndexFile, [resolveReference(CloudSettingHelpers.AzureClouds)]);
+    addExportsToRootIndexFile(
+      rootIndexFile,
+      [resolveReference(CloudSettingHelpers.AzureSupportedClouds)],
+      true,
+    );
+  }
+}
+
+function exportRestErrorTypes(rootIndexFile: SourceFile) {
+  const existingExports = getExistingExports(rootIndexFile);
+  const namedExports = ["RestError", "isRestError"].filter((name) => !existingExports.has(name));
+  if (namedExports.length > 0) {
+    rootIndexFile.addExportDeclaration({
+      moduleSpecifier: "@azure/core-rest-pipeline",
+      namedExports,
+    });
+  }
+}
+
+/**
+ * This is a temporary solution for adding paging exports. Eventually we will have the binder generate the exports automatically.
+ */
+function exportPagingTypes(context: SdkContext, rootIndexFile: SourceFile) {
+  if (!hasPaging(context)) {
+    return;
+  }
+
+  addExportsToRootIndexFile(
+    rootIndexFile,
+    [
+      resolveReference(PagingHelpers.PageSettings),
+      resolveReference(PagingHelpers.ContinuablePage),
+      resolveReference(PagingHelpers.PagedAsyncIterableIterator),
+    ],
+    true,
+  );
+}
+
+function hasPaging(context: SdkContext): boolean {
+  return context.sdkPackage.clients.some((client) => {
+    const methodMap = getMethodHierarchiesMap(context, client);
+    for (const [_, operations] of methodMap) {
+      if (operations.some((op) => op.kind === "paging" || op.kind === "lropaging")) {
+        return true;
+      }
+    }
+    return false;
+  });
+}
+
+function exportFileContentsType(context: SdkContext, rootIndexFile: SourceFile) {
+  const hasMultipartFileParts = context.sdkPackage.models.some((x) =>
+    x.properties.some((y) => y.kind === "property" && y.serializationOptions.multipart?.isFilePart),
+  );
+
+  if (hasMultipartFileParts) {
+    addExportsToRootIndexFile(
+      rootIndexFile,
+      [
+        resolveReference(MultipartHelpers.FileContents),
+        resolveReference(PlatformTypeHelpers.NodeReadableStream),
+      ],
+      true,
+    );
+  }
+}
+
+function getExistingExports(rootIndexFile: SourceFile): Set<string> {
+  return new Set(
+    rootIndexFile
+      .getExportDeclarations()
+      .flatMap((exportDecl) =>
+        exportDecl.getNamedExports().map((namedExport) => namedExport.getName()),
+      ),
+  );
+}
+
+function getNewNamedExports(namedExports: string[], existingExports: Set<string>): string[] {
+  return namedExports.filter((namedExport) => !existingExports.has(namedExport));
+}
+
+function addExportsToRootIndexFile(
+  rootIndexFile: SourceFile,
+  namedExports: string[],
+  isTypeOnly: boolean = false,
+) {
+  const existingExports = getExistingExports(rootIndexFile);
+  const newNamedExports = getNewNamedExports(namedExports, existingExports);
+  if (newNamedExports.length > 0) {
+    rootIndexFile.addExportDeclaration({
+      isTypeOnly,
+      namedExports: newNamedExports,
+    });
+  }
+}
+
+function exportSimplePollerLike(
+  context: SdkContext,
+  clientMap: [string[], SdkClientType<SdkServiceOperation>],
+  indexFile: SourceFile,
+  project: Project,
+  srcPath: string,
+  subfolder: string = "",
+  isTopLevel: boolean = false,
+) {
+  const [_, client] = clientMap;
+
+  const methodMap = getMethodHierarchiesMap(context, client);
+  const hasLro = Array.from(methodMap.values()).some((operations) => {
+    return operations.some(isLroOnlyOperation);
+  });
+  if (!hasLro || context.rlcOptions?.compatibilityLro !== true) {
+    return;
+  }
+  const helperFile = project.getSourceFile(
+    `${srcPath}/${
+      subfolder && subfolder !== "" ? subfolder + "/" : ""
+    }static-helpers/simplePollerHelpers.ts`,
+  );
+  if (!helperFile) {
+    return;
+  }
+  const moduleSpecifier = `./${
+    isTopLevel && subfolder && subfolder !== "" ? subfolder + "/" : ""
+  }static-helpers/simplePollerHelpers.js`;
+  indexFile.addExportDeclaration({
+    isTypeOnly: true,
+    moduleSpecifier,
+    namedExports: ["SimplePollerLike"],
+  });
+}
+
+function exportRestoreHelpers(
+  indexFile: SourceFile,
+  project: Project,
+  srcPath: string,
+  clientName: string,
+  subfolder: string = "",
+  isTopLevel: boolean = false,
+) {
+  const helperFile = project.getSourceFile(
+    `${srcPath}/${subfolder && subfolder !== "" ? subfolder + "/" : ""}restorePollerHelpers.ts`,
+  );
+  if (!helperFile) {
+    return;
+  }
+  const exported = new Set(indexFile.getExportedDeclarations().keys());
+  const allEntries = [...helperFile.getExportedDeclarations().entries()];
+  const moduleSpecifier = `./${
+    isTopLevel && subfolder && subfolder !== "" ? subfolder + "/" : ""
+  }restorePollerHelpers.js`;
+  const renamer = (name: string) => (exported.has(name) ? `${name} as ${clientName}${name}` : name);
+  partitionAndEmitExports(indexFile, moduleSpecifier, allEntries, renamer);
+}
+
+function exportClassicalClient(
+  client: SdkClientType<SdkServiceOperation>,
+  indexFile: SourceFile,
+  subfolder: string,
+  isSubClient: boolean = false,
+) {
+  const clientName = client.name;
+  indexFile.addExportDeclaration({
+    namedExports: [clientName],
+    moduleSpecifier: `./${
+      subfolder && subfolder !== "" && !isSubClient ? subfolder + "/" : ""
+    }${normalizeName(clientName, NameType.File)}.js`,
+  });
+}
+
+export interface ExportModulesOptions {
+  interfaceOnly?: boolean;
+  isTopLevel?: boolean;
+  subfolder?: string;
+  recursive?: boolean;
+}
+
+function exportModules(
+  indexFile: SourceFile,
+  project: Project,
+  srcPath: string,
+  clientName: string,
+  moduleName: string,
+  options: ExportModulesOptions = {
+    interfaceOnly: false,
+    isTopLevel: false,
+    subfolder: "",
+    recursive: false,
+  },
+) {
+  const subfolder = options.subfolder ?? "";
+  let folders: string[];
+  if (options.recursive) {
+    folders = project
+      .getDirectories()
+      .filter((dir) => {
+        const formattedDir = dir.getPath().replace(/\\/g, "/");
+        const targetPath = joinPaths(srcPath, subfolder, moduleName).replace(/\\/g, "/");
+        return formattedDir.startsWith(targetPath);
+      })
+      .map((dir) => {
+        return dir.getPath().replace(/\\/g, "/");
+      });
+  } else if (options.isTopLevel && moduleName === "api") {
+    folders = project
+      .getDirectories()
+      .filter((dir) => {
+        const formattedDir = dir.getPath().replace(/\\/g, "/");
+        const targetPath = joinPaths(srcPath, subfolder, moduleName).replace(/\\/g, "/");
+        return formattedDir.startsWith(targetPath);
+      })
+      .map((dir) => {
+        return dir.getPath().replace(/\\/g, "/");
+      });
+  } else {
+    folders = [joinPaths(srcPath, subfolder, moduleName).replace(/\\/g, "/")];
+  }
+  for (const folder of folders) {
+    const apiFilePattern = joinPaths(folder, "index.ts").replace(/\\/g, "/");
+    const modelsFile = project.getSourceFile(apiFilePattern);
+    if (!modelsFile) {
+      continue;
+    }
+
+    const exported = new Set(indexFile.getExportedDeclarations().keys());
+    const serializerOrDeserializerRegex = /.*(Serializer|Deserializer)(_\d+)?$/;
+    const filteredEntries = [...modelsFile.getExportedDeclarations().entries()].filter(
+      (exDeclaration) => {
+        if (exDeclaration[0].startsWith("_")) {
+          return false;
+        }
+        return exDeclaration[1].some((ex) => {
+          if (options.interfaceOnly && ex.getKindName() !== "InterfaceDeclaration") {
+            return false;
+          }
+          if (
+            moduleName === "models" &&
+            ex.getKindName() === "FunctionDeclaration" &&
+            serializerOrDeserializerRegex.test(exDeclaration[0])
+          ) {
+            return false;
+          }
+          if (options.interfaceOnly && options.isTopLevel && exDeclaration[0].endsWith("Context")) {
+            return false;
+          }
+
+          return true;
+        });
+      },
+    );
+    const moduleSpecifier = `.${modelsFile
+      .getFilePath()
+      .replace(indexFile.getDirectoryPath(), "")
+      .replace(/\\/g, "/")
+      .replace(".ts", "")}.js`;
+    const renamer = (name: string) =>
+      exported.has(name) ? `${name} as ${clientName}${name}` : name;
+    partitionAndEmitExports(indexFile, moduleSpecifier, filteredEntries, renamer);
+  }
+}
+
+export function buildSubClientIndexFile(
+  context: SdkContext,
+  clientMap: [string[], SdkClientType<SdkServiceOperation>],
+  emitterOptions: ModularEmitterOptions,
+) {
+  const project = useContext("outputProject");
+  const [_, client] = clientMap;
+  const { subfolder } = getModularClientOptions(clientMap);
+  const srcPath = emitterOptions.modularOptions.sourceRoot;
+  const subClientIndexFile = project.createSourceFile(
+    `${srcPath}/${subfolder && subfolder !== "" ? subfolder + "/" : ""}index.ts`,
+    undefined,
+    { overwrite: true },
+  );
+  const clientName = `${getClassicalClientName(client)}`;
+  const clientFilePath = `${srcPath}/${
+    subfolder && subfolder !== "" ? subfolder + "/" : ""
+  }${normalizeName(clientName, NameType.File)}.ts`;
+  const clientFile = project.getSourceFile(clientFilePath);
+
+  if (!clientFile) {
+    reportDiagnostic(context.program, {
+      code: "client-file-not-found",
+      format: {
+        filePath: clientFilePath,
+      },
+      target: NoTarget,
+    });
+    return; // Skip exporting this client but continue with others
+  }
+
+  exportClassicalClient(client, subClientIndexFile, subfolder ?? "", true);
+  exportSimplePollerLike(context, clientMap, subClientIndexFile, project, srcPath, subfolder);
+  exportRestoreHelpers(subClientIndexFile, project, srcPath, clientName, subfolder);
+  exportModules(subClientIndexFile, project, srcPath, clientName, "api", {
+    subfolder,
+    interfaceOnly: true,
+    recursive: true,
+  });
+  exportModules(subClientIndexFile, project, srcPath, clientName, "classic", {
+    subfolder,
+  });
+}