@azure-tools/typespec-ts 0.31.0 → 0.32.0

package/src/modular/buildOperations.ts

@@ -8,11 +8,11 @@ import {
 import { Project, SourceFile } from "ts-morph";
 import { isRLCMultiEndpoint } from "../utils/clientUtils.js";
 import { SdkContext } from "../utils/interfaces.js";
-import { importLroCoreDependencies } from "./buildLroFiles.js";
 import { getDocsFromDescription } from "./helpers/docsHelpers.js";
 import { getOperationName } from "./helpers/namingHelpers.js";
 import {
   getDeserializePrivateFunction,
+  getExpectedStatuses,
   getOperationFunction,
   getOperationOptionsName,
   getSendPrivateFunction,
@@ -30,8 +30,7 @@ import { addImportBySymbol } from "../utils/importHelper.js";
 export function buildOperationFiles(
   client: Client,
   dpgContext: SdkContext,
-  codeModel: ModularCodeModel,
-  needUnexpectedHelper: boolean = true
+  codeModel: ModularCodeModel
 ) {
   const operationFiles = [];
   const isMultiEndpoint = isRLCMultiEndpoint(dpgContext);
@@ -58,11 +57,6 @@ export function buildOperationFiles(
         subfolder && subfolder !== "" ? subfolder + "/" : ""
       }api/${operationFileName}.ts`
     );
-    // We need to import the lro helpers and types explicitly because ts-morph may not be able to find correct ones.
-    importLroDependencies(
-      operationGroupFile,
-      operationGroup.namespaceHierarchies.length
-    );
 
     // Import models used from ./models.ts
     // We SHOULD keep this because otherwise ts-morph will "helpfully" try to import models from the rest layer when we call fixMissingImports().
@@ -94,46 +88,13 @@ export function buildOperationFiles(
       operationGroup.namespaceHierarchies.length
     );
 
-    // We need to import the paging helpers and types explicitly because ts-morph may not be able to find them.
-    importPagingDependencies(
-      srcPath,
-      operationGroupFile,
-      codeModel.project,
-      subfolder,
-      operationGroup.namespaceHierarchies.length
-    );
+    const indexPathPrefix =
+      "../".repeat(operationGroup.namespaceHierarchies.length) || "./";
+    operationGroupFile.addImportDeclaration({
+      namedImports: [`${client.rlcClientName} as Client`],
+      moduleSpecifier: `${indexPathPrefix}index.js`
+    });
 
-    const namedImports: string[] = [];
-    if (isMultiEndpoint) {
-      namedImports.push(`Client`);
-      if (needUnexpectedHelper) {
-        namedImports.push("UnexpectedHelper");
-      }
-      operationGroupFile.addImportDeclarations([
-        {
-          moduleSpecifier: `../${"../".repeat(
-            operationGroup.namespaceHierarchies.length
-          )}rest/${subfolder}/index.js`,
-          namedImports
-        }
-      ]);
-    } else {
-      if (needUnexpectedHelper) {
-        namedImports.push("isUnexpected");
-      }
-      const rlcClientName = client.rlcClientName;
-      namedImports.push(`${rlcClientName} as Client`);
-      operationGroupFile.addImportDeclarations([
-        {
-          moduleSpecifier: `${
-            subfolder && subfolder !== "" ? "../" : ""
-          }${"../".repeat(
-            operationGroup.namespaceHierarchies.length + 1
-          )}rest/index.js`,
-          namedImports
-        }
-      ]);
-    }
     operationGroup.operations.forEach((o) => {
       const operationDeclaration = getOperationFunction(o, clientType);
       const sendOperationDeclaration = getSendPrivateFunction(
@@ -144,8 +105,6 @@ export function buildOperationFiles(
       );
       const deserializeOperationDeclaration = getDeserializePrivateFunction(
         o,
-        isMultiEndpoint,
-        needUnexpectedHelper,
         codeModel.runtimeImports
       );
       operationGroupFile.addFunctions([
@@ -171,9 +130,6 @@ export function buildOperationFiles(
     addImportsToFiles(codeModel.runtimeImports, operationGroupFile);
     addImportBySymbol("serializeRecord", operationGroupFile);
 
-    operationGroupFile.fixMissingImports();
-    // have to fixUnusedIdentifiers after everything get generated.
-    operationGroupFile.fixUnusedIdentifiers();
     operationFiles.push(operationGroupFile);
   }
   return operationFiles;
@@ -246,64 +202,6 @@ export function importDeserializeUtils(
     });
   }
 }
-// Import all deserializeUtil and then let ts-morph clean up the unused ones
-// we can't fixUnusedIdentifiers here because the operaiton files are still being generated.
-// sourceFile.fixUnusedIdentifiers();
-export function importPagingDependencies(
-  srcPath: string,
-  sourceFile: SourceFile,
-  project: Project,
-  subfolder: string = "",
-  importLayer: number = 0
-) {
-  const pagingTypes = project.getSourceFile(
-    `${srcPath}/${subfolder !== "" ? subfolder + "/" : ""}models/pagingTypes.ts`
-  );
-
-  if (!pagingTypes) {
-    return;
-  }
-
-  const exportedPaingTypes = [...pagingTypes.getExportedDeclarations().keys()];
-
-  sourceFile.addImportDeclaration({
-    moduleSpecifier: `${"../".repeat(importLayer + 1)}models/pagingTypes.js`,
-    namedImports: exportedPaingTypes
-  });
-
-  const pagingHelper = project.getSourceFile(
-    `${srcPath}/${subfolder !== "" ? subfolder + "/" : ""}api/pagingHelpers.ts`
-  );
-
-  if (!pagingHelper) {
-    return;
-  }
-
-  const exportedPaingHelpers = [
-    ...pagingHelper.getExportedDeclarations().keys()
-  ];
-
-  sourceFile.addImportDeclaration({
-    moduleSpecifier: `${
-      importLayer === 0 ? "./" : "../".repeat(importLayer)
-    }pagingHelpers.js`,
-    namedImports: exportedPaingHelpers
-  });
-}
-
-export function importLroDependencies(
-  sourceFile: SourceFile,
-  importLayer: number = 0
-) {
-  sourceFile.addImportDeclaration({
-    moduleSpecifier: `${
-      importLayer === 0 ? "./" : "../".repeat(importLayer)
-    }pollingHelpers.js`,
-    namedImports: ["getLongRunningPoller"]
-  });
-
-  importLroCoreDependencies(sourceFile);
-}
 
 /**
  * This function generates the interfaces for each operation options
@@ -383,6 +281,7 @@ export function buildLroDeserDetailMap(client: Client) {
         existingNames.add(deserName);
         return {
           path: `${o.method.toUpperCase()} ${o.url}`,
+          expectedStatusesExpression: getExpectedStatuses(o),
           deserName,
           renamedDeserName
         };

package/src/modular/buildRestorePoller.ts

@@ -0,0 +1,239 @@
+import { SourceFile } from "ts-morph";
+import { isLroOnlyOperation } from "./helpers/operationHelpers.js";
+import { ModularCodeModel, Client } from "./modularCodeModel.js";
+import path from "path";
+import { buildLroDeserDetailMap } from "./buildOperations.js";
+import { getClientName } from "./helpers/namingHelpers.js";
+import { NameType, normalizeName } from "@azure-tools/rlc-common";
+import { resolveReference } from "../framework/reference.js";
+import {
+  AzureCoreDependencies,
+  AzurePollingDependencies
+} from "./external-dependencies.js";
+import { PollingHelpers } from "./static-helpers-metadata.js";
+
+export function buildRestorePoller(
+  codeModel: ModularCodeModel,
+  client: Client
+) {
+  const lros = client.operationGroups
+    .flatMap((op) => op.operations)
+    .filter(isLroOnlyOperation);
+  if (lros.length === 0) {
+    return;
+  }
+  const srcPath = codeModel.modularOptions.sourceRoot;
+  const subfolder = client.subfolder ?? "";
+  const filePath = path.join(
+    `${srcPath}/${
+      subfolder !== "" ? subfolder + "/" : ""
+    }restorePollerHelpers.ts`
+  );
+  const restorePollerFile = codeModel.project.createSourceFile(
+    filePath,
+    undefined,
+    {
+      overwrite: true
+    }
+  );
+
+  const clientNames = importClassicalClient(client, restorePollerFile);
+  const deserializeMap = importDeserializeHelpers(client, restorePollerFile);
+  const pathUncheckedReference = resolveReference(
+    AzureCoreDependencies.PathUncheckedResponse
+  );
+  const pollerLikeReference = resolveReference(
+    AzurePollingDependencies.PollerLike
+  );
+  const operationStateReference = resolveReference(
+    AzurePollingDependencies.OperationState
+  );
+  const operationOptionsReference = resolveReference(
+    AzureCoreDependencies.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(AzureCoreDependencies.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}.\`
+        );
+      }
+      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
+        }
+      );
+    }
+    
+    interface DeserializationHelper {
+      deserializer: Function;
+      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);
+    }      
+  `;
+  restorePollerFile.addStatements(restorePollerHelperContent);
+}
+
+function importDeserializeHelpers(client: Client, sourceFile: SourceFile) {
+  const deserializeDetails = buildLroDeserDetailMap(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: Client,
+  sourceFile: SourceFile
+): string[] {
+  const classicalClientName = `${getClientName(client)}Client`;
+  sourceFile.addImportDeclaration({
+    namedImports: [`${classicalClientName}`],
+    moduleSpecifier: `./${normalizeName(classicalClientName, NameType.File)}.js`
+  });
+  return [classicalClientName];
+}

package/src/modular/buildRootIndex.ts

@@ -2,6 +2,8 @@ import { NameType, normalizeName } from "@azure-tools/rlc-common";
 import { Project, SourceFile } from "ts-morph";
 import { getClientName } from "./helpers/namingHelpers.js";
 import { Client, ModularCodeModel } from "./modularCodeModel.js";
+import { resolveReference } from "../framework/reference.js";
+import { PagingHelpers } from "./static-helpers-metadata.js";
 
 export function buildRootIndex(
   client: Client,
@@ -55,6 +57,72 @@ export function buildRootIndex(
     subfolder,
     true
   );
+
+  exportPagingTypes(codeModel, rootIndexFile);
+}
+
+/**
+ * This is a temporary solution for adding paging exports. Eventually we will have the binder generate the exports automatically.
+ */
+function exportPagingTypes(
+  codeModel: ModularCodeModel,
+  rootIndexFile: SourceFile
+) {
+  if (!hasPaging(codeModel)) {
+    return;
+  }
+
+  const existingExports = getExistingExports(rootIndexFile);
+  const namedExports = [
+    resolveReference(PagingHelpers.PageSettings),
+    resolveReference(PagingHelpers.ContinuablePage),
+    resolveReference(PagingHelpers.PagedAsyncIterableIterator)
+  ];
+
+  const newNamedExports = getNewNamedExports(namedExports, existingExports);
+
+  if (newNamedExports.length > 0) {
+    addExportsToRootIndexFile(rootIndexFile, newNamedExports);
+  }
+}
+
+function hasPaging(codeModel: ModularCodeModel): boolean {
+  return codeModel.clients.some((c) =>
+    c.operationGroups.some((og) =>
+      og.operations.some(
+        (op) =>
+          op.discriminator === "paging" || op.discriminator === "lropaging"
+      )
+    )
+  );
+}
+
+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,
+  newNamedExports: string[]
+) {
+  rootIndexFile.addExportDeclaration({
+    namedExports: newNamedExports
+  });
 }
 
 function exportRestoreHelpers(

package/src/modular/emitLoggerFile.ts

@@ -0,0 +1,28 @@
+import { Project } from "ts-morph";
+import { ModularCodeModel } from "./modularCodeModel.js";
+
+export function emitLoggerFile(
+  codeModel: ModularCodeModel,
+  project: Project,
+  srcPath: string = "src"
+) {
+  if (codeModel.options.flavor !== "azure") {
+    return;
+  }
+
+  const sourceFile = project.createSourceFile(`${srcPath}/logger.ts`, "", {
+    overwrite: true
+  });
+
+  sourceFile.addImportDeclaration({
+    namedImports: ["createClientLogger"],
+    moduleSpecifier: "@azure/logger"
+  });
+
+  const name =
+    codeModel.options.packageDetails?.nameWithoutScope ??
+    codeModel.options.packageDetails?.name;
+  sourceFile.addStatements(
+    `export const logger = createClientLogger("${name}");`
+  );
+}

package/src/modular/emitModels.ts

@@ -253,7 +253,6 @@ export function buildModels(
 
   const projectRootFromModels = codeModel.clients.length > 1 ? "../.." : "../";
   addImportsToFiles(codeModel.runtimeImports, modelsFile, {
-    rlcIndex: path.posix.join(projectRootFromModels, "rest", "index.js"),
     serializerHelpers: path.posix.join(
       projectRootFromModels,
       "helpers",
@@ -394,13 +393,6 @@ export function buildModelsOptions(
     }
   ]);
 
-  modelOptionsFile.fixMissingImports(
-    {},
-    {
-      importModuleSpecifierPreference: "shortest",
-      importModuleSpecifierEnding: "js"
-    }
-  );
   modelOptionsFile
     .getImportDeclarations()
     .filter((id) => {

package/src/modular/external-dependencies.ts

@@ -0,0 +1,140 @@
+import { CoreDependencies } from "../framework/dependency.js";
+
+export const DefaultCoreDependencies: CoreDependencies = {
+  Client: {
+    kind: "externalDependency",
+    name: "Client",
+    module: "@typespec/ts-http-runtime"
+  },
+  ClientOptions: {
+    kind: "externalDependency",
+    name: "ClientOptions",
+    module: "@typespec/ts-http-runtime"
+  },
+  Pipeline: {
+    kind: "externalDependency",
+    name: "Pipeline",
+    module: "@typespec/ts-http-runtime"
+  },
+  getClient: {
+    kind: "externalDependency",
+    name: "getClient",
+    module: "@typespec/ts-http-runtime"
+  },
+  RestError: {
+    kind: "externalDependency",
+    name: "RestError",
+    module: "@typespec/ts-http-runtime"
+  },
+  OperationOptions: {
+    kind: "externalDependency",
+    name: "OperationOptions",
+    module: "@typespec/ts-http-runtime"
+  },
+  PathUncheckedResponse: {
+    kind: "externalDependency",
+    name: "PathUncheckedResponse",
+    module: "@typespec/ts-http-runtime"
+  },
+  AbortSignalLike: {
+    kind: "externalDependency",
+    name: "AbortSignalLike",
+    module: "@typespec/ts-http-runtime"
+  },
+  createRestError: {
+    kind: "externalDependency",
+    name: "createRestError",
+    module: "@typespec/ts-http-runtime"
+  },
+  operationOptionsToRequestParameters: {
+    kind: "externalDependency",
+    name: "operationOptionsToRequestParameters",
+    module: "@typespec/ts-http-runtime"
+  },
+  uint8ArrayToString: {
+    kind: "externalDependency",
+    name: "uint8ArrayToString",
+    module: "@typespec/ts-http-runtime"
+  }
+} as const;
+
+export const AzurePollingDependencies = {
+  PollerLike: {
+    kind: "externalDependency",
+    module: "@azure/core-lro",
+    name: "PollerLike"
+  },
+  OperationState: {
+    kind: "externalDependency",
+    module: "@azure/core-lro",
+    name: "OperationState"
+  },
+  DeserializeState: {
+    kind: "externalDependency",
+    module: "@azure/core-lro",
+    name: "deserializeState"
+  },
+  ResourceLocationConfig: {
+    kind: "externalDependency",
+    module: "@azure/core-lro",
+    name: "ResourceLocationConfig"
+  }
+};
+
+export const AzureCoreDependencies: CoreDependencies = {
+  Client: {
+    kind: "externalDependency",
+    module: "@azure-rest/core-client",
+    name: "Client"
+  },
+  ClientOptions: {
+    kind: "externalDependency",
+    module: "@azure-rest/core-client",
+    name: "ClientOptions"
+  },
+  Pipeline: {
+    kind: "externalDependency",
+    module: "@azure-rest/core-client",
+    name: "Pipeline"
+  },
+  getClient: {
+    kind: "externalDependency",
+    module: "@azure-rest/core-client",
+    name: "getClient"
+  },
+  RestError: {
+    kind: "externalDependency",
+    module: "@azure-rest/core-client",
+    name: "RestError"
+  },
+  OperationOptions: {
+    kind: "externalDependency",
+    module: "@azure-rest/core-client",
+    name: "OperationOptions"
+  },
+  PathUncheckedResponse: {
+    kind: "externalDependency",
+    module: "@azure-rest/core-client",
+    name: "PathUncheckedResponse"
+  },
+  AbortSignalLike: {
+    kind: "externalDependency",
+    module: "@azure/abort-controller",
+    name: "AbortSignalLike"
+  },
+  createRestError: {
+    kind: "externalDependency",
+    module: "@azure-rest/core-client",
+    name: "createRestError"
+  },
+  operationOptionsToRequestParameters: {
+    kind: "externalDependency",
+    module: "@azure-rest/core-client",
+    name: "operationOptionsToRequestParameters"
+  },
+  uint8ArrayToString: {
+    kind: "externalDependency",
+    module: "@azure/core-util",
+    name: "uint8ArrayToString"
+  }
+};