@azure-tools/typespec-ts 0.54.0 → 0.54.2

package/src/modular/build-project-files.ts

@@ -0,0 +1,111 @@
+import { NameType } from "../rlc-common/index.js";
+
+import path from "path/posix";
+import { useContext } from "../context-manager.js";
+import { getClientHierarchyMap, getModularClientOptions } from "../utils/client-utils.js";
+import { SdkContext } from "../utils/interfaces.js";
+import { getMethodHierarchiesMap } from "../utils/operation-util.js";
+import { getClassicalLayerPrefix } from "./helpers/naming-helpers.js";
+import { ModularEmitterOptions } from "./interfaces.js";
+
+/**
+ * Computes the relative path prefix (e.g. `./src` or `./src/generated`) from
+ * the project root to the modular sources directory.  This prefix is used when
+ * building export map entries so that they always point to the correct folder
+ * even when the generated code lives under `src/generated` instead of `src`.
+ */
+function getSourceRootPrefix(emitterOptions: ModularEmitterOptions, context: SdkContext): string {
+  const sourceRoot = emitterOptions.modularOptions.sourceRoot.replace(/\\/g, "/");
+  const rootDir = (context.generationPathDetail?.rootDir ?? "").replace(/\\/g, "/");
+
+  if (rootDir && sourceRoot.startsWith(rootDir)) {
+    const relativePath = path.relative(rootDir, sourceRoot).replace(/\\/g, "/");
+    return `./${relativePath}`;
+  }
+
+  return "./src";
+}
+
+function buildExportsForMultiClient(
+  context: SdkContext,
+  emitterOptions: ModularEmitterOptions,
+  packageInfo: any,
+) {
+  const srcPrefix = getSourceRootPrefix(emitterOptions, context);
+  const clientMap = getClientHierarchyMap(context);
+  let hasTopLevelClient = false;
+  for (const [hierarchy, client] of clientMap) {
+    const methodMap = getMethodHierarchiesMap(context, client);
+    if (hierarchy.length === 0) {
+      hasTopLevelClient = true;
+    }
+    const { subfolder } = getModularClientOptions([hierarchy, client]);
+    if (subfolder !== "" && methodMap.size > 0) {
+      packageInfo.exports[`./${subfolder}`] = `${srcPrefix}/${subfolder}/index.ts`;
+
+      packageInfo.exports[`./${subfolder}/api`] = `${srcPrefix}/${subfolder}/api/index.ts`;
+    }
+  }
+  if (!hasTopLevelClient) {
+    delete packageInfo.exports["./api"];
+  }
+  if (emitterOptions.options.hierarchyClient) {
+    // TODO: support api subpath exports for multi-service. Skip for now. https://github.com/Azure/autorest.typescript/issues/3717
+    if (!emitterOptions.options.isMultiService) {
+      for (const flattenedClient of clientMap) {
+        const { subfolder } = getModularClientOptions(flattenedClient);
+        const client = flattenedClient[1];
+        const methodMap = getMethodHierarchiesMap(context, client);
+        for (const [prefixKey, _] of methodMap) {
+          const prefixes = prefixKey.split("/");
+          if (prefixKey === "") {
+            continue;
+          }
+          const subApiPath = `api/${getClassicalLayerPrefix(prefixes, NameType.File, "/")}`;
+
+          packageInfo.exports[`./${subfolder ? subfolder + "/" : ""}${subApiPath}`] =
+            `${srcPrefix}/${subfolder ? subfolder + "/" : ""}${subApiPath}/index.ts`;
+        }
+      }
+    }
+    delete packageInfo.exports["./models"];
+    const modelSubpaths = getModelSubpaths(emitterOptions);
+    for (const modelSubpath of modelSubpaths) {
+      packageInfo.exports[`./${modelSubpath.replace("/index.ts", "")}`] =
+        `${srcPrefix}/${modelSubpath}`;
+    }
+  }
+
+  return packageInfo.exports;
+}
+
+export function getModuleExports(context: SdkContext, emitterOptions: ModularEmitterOptions) {
+  const srcPrefix = getSourceRootPrefix(emitterOptions, context);
+  const exports: Record<string, any> = {
+    exports: {
+      ".": `${srcPrefix}/index.ts`,
+      "./models": `${srcPrefix}/models/index.ts`,
+    },
+  };
+  exports["exports"]["./api"] = `${srcPrefix}/api/index.ts`;
+
+  return buildExportsForMultiClient(context, emitterOptions, exports);
+}
+
+function getModelSubpaths(emitterOptions: ModularEmitterOptions) {
+  const outputProject = useContext("outputProject");
+  const modelFiles = outputProject.getSourceFiles(
+    path.join(emitterOptions.modularOptions.sourceRoot.replace(/\\/g, "/"), `models/**/*.ts`),
+  );
+  const subpath = new Set<string>();
+  for (const modelFile of modelFiles) {
+    const filepath = modelFile.getFilePath().replace(/\\/g, "/");
+    if (!filepath.endsWith("index.ts")) {
+      continue;
+    }
+    subpath.add(
+      path.relative(emitterOptions.modularOptions.sourceRoot.replace(/\\/g, "/"), filepath),
+    );
+  }
+  return Array.from(subpath);
+}

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

@@ -0,0 +1,242 @@
+import { SdkClientType, SdkServiceOperation } from "@azure-tools/typespec-client-generator-core";
+import path from "path";
+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 = path.join(
+    `${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];
+}