@azure-tools/typespec-ts 0.54.1 → 0.54.2

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

@@ -0,0 +1,152 @@
+import { SdkClientType, SdkServiceOperation } from "@azure-tools/typespec-client-generator-core";
+import { ModularEmitterOptions } from "./interfaces.js";
+
+import { join } from "path";
+import { Node, SourceFile } from "ts-morph";
+import { useContext } from "../context-manager.js";
+import { getModularClientOptions } from "../utils/client-utils.js";
+
+export interface buildSubpathIndexFileOptions {
+  exportIndex?: boolean;
+  interfaceOnly?: boolean;
+  recursive?: boolean;
+}
+
+export function buildSubpathIndexFile(
+  emitterOptions: ModularEmitterOptions,
+  subpath: string,
+  clientMap?: [string[], SdkClientType<SdkServiceOperation>],
+  options: buildSubpathIndexFileOptions = {},
+) {
+  const project = useContext("outputProject");
+  const subfolder = clientMap ? (getModularClientOptions(clientMap).subfolder ?? "") : "";
+  const srcPath = emitterOptions.modularOptions.sourceRoot;
+  // Skip to export these files because they are used internally.
+  const skipFiles = ["pagingHelpers.ts", "pollingHelpers.ts"];
+  let folders: string[];
+  if (options.recursive) {
+    folders = project
+      .getDirectories()
+      .filter((dir) => {
+        const formattedDir = dir.getPath().replace(/\\/g, "/");
+        const targetPath = join(srcPath, subfolder, subpath).replace(/\\/g, "/");
+        return (
+          formattedDir.startsWith(targetPath) && !project.getSourceFile(`${formattedDir}/index.ts`)
+        );
+      })
+      .map((dir) => {
+        return dir.getPath().replace(/\\/g, "/");
+      });
+  } else {
+    folders = [join(srcPath, subfolder, subpath).replace(/\\/g, "/")];
+  }
+  for (const folder of folders) {
+    const apiFilePattern = subpath === "models" ? join(folder, "models.ts") : folder;
+    const apiFiles = project.getSourceFiles().filter((file) => {
+      if (subpath === "api" && options.recursive) {
+        return file.getDirectoryPath().replace(/\\/g, "/") === apiFilePattern.replace(/\\/g, "/");
+      }
+      return file
+        .getFilePath()
+        .replace(/\\/g, "/")
+        .startsWith(
+          apiFilePattern.replace(/\\/g, "/") + (apiFilePattern.endsWith("models.ts") ? "" : "/"),
+        );
+    });
+    if (apiFiles.length === 0) {
+      continue;
+    }
+    const indexFile = project.createSourceFile(`${folder}/index.ts`);
+    for (const file of apiFiles) {
+      const filePath = file.getFilePath();
+      const serializerOrDeserializerRegex = /.*(Serializer|Deserializer)(_\d+)?$/;
+      if (!options.exportIndex && filePath.endsWith("index.ts")) {
+        continue;
+      }
+      // Skip to export these files because they are used internally.
+      if (skipFiles.some((skipFile) => filePath.endsWith(skipFile))) {
+        continue;
+      }
+      if (filePath === indexFile.getFilePath()) {
+        continue;
+      }
+
+      let filteredDeclarations = [...file.getExportedDeclarations().entries()].filter(
+        (exDeclaration) => {
+          if (exDeclaration[0].startsWith("_")) {
+            return false;
+          }
+          return exDeclaration[1].some((ex) => {
+            if (options.interfaceOnly && ex.getKindName() !== "InterfaceDeclaration") {
+              return false;
+            }
+
+            // skip exporting serializers for models
+            if (
+              subpath === "models" &&
+              ex.getKindName() === "FunctionDeclaration" &&
+              serializerOrDeserializerRegex.test(exDeclaration[0])
+            ) {
+              return false;
+            }
+
+            return true;
+          });
+        },
+      );
+      // Skip to export PagedResult and BuildPagedAsyncIteratorOptions
+      if (filePath.endsWith("pagingTypes.ts")) {
+        filteredDeclarations = filteredDeclarations.filter(
+          ([name]) => !["PagedResult", "BuildPagedAsyncIteratorOptions"].includes(name),
+        );
+      }
+      if (filteredDeclarations.length > 0) {
+        const moduleSpecifier = `.${filePath
+          .replace(indexFile.getDirectoryPath(), "")
+          .replace(/\\/g, "/")
+          .replace(".ts", "")}.js`;
+        partitionAndEmitExports(indexFile, moduleSpecifier, filteredDeclarations);
+      }
+    }
+  }
+}
+
+export function isTypeOnlyNode(node: Node): boolean {
+  const kind = node.getKindName();
+  return kind === "InterfaceDeclaration" || kind === "TypeAliasDeclaration";
+}
+
+/**
+ * Partition declaration entries into type-only and value exports in a single pass,
+ * then emit both export declarations on the index file.
+ */
+export function partitionAndEmitExports(
+  indexFile: SourceFile,
+  moduleSpecifier: string,
+  entries: [string, Node[]][],
+  mapName: (name: string) => string = (n) => n,
+): void {
+  const typeOnlyExports: string[] = [];
+  const valueExports: string[] = [];
+  for (const [name, decls] of entries) {
+    const mapped = mapName(name);
+    if (decls.every(isTypeOnlyNode)) {
+      typeOnlyExports.push(mapped);
+    } else {
+      valueExports.push(mapped);
+    }
+  }
+  if (typeOnlyExports.length > 0) {
+    indexFile.addExportDeclaration({
+      isTypeOnly: true,
+      moduleSpecifier,
+      namedExports: typeOnlyExports,
+    });
+  }
+  if (valueExports.length > 0) {
+    indexFile.addExportDeclaration({
+      moduleSpecifier,
+      namedExports: valueExports,
+    });
+  }
+}

package/src/modular/emit-logger-file.ts

@@ -0,0 +1,23 @@
+import { useContext } from "../context-manager.js";
+import { ModularEmitterOptions } from "./interfaces.js";
+
+export function emitLoggerFile(emitterOptions: ModularEmitterOptions, srcPath: string = "src") {
+  const project = useContext("outputProject");
+  if (emitterOptions.options.flavor !== "azure") {
+    return;
+  }
+
+  const sourceFile = project.createSourceFile(`${srcPath}/logger.ts`, "", {
+    overwrite: true,
+  });
+
+  sourceFile.addImportDeclaration({
+    namedImports: ["createClientLogger"],
+    moduleSpecifier: "@azure/logger",
+  });
+
+  const name =
+    emitterOptions.options.packageDetails?.nameWithoutScope ??
+    emitterOptions.options.packageDetails?.name;
+  sourceFile.addStatements(`export const logger = createClientLogger("${name}");`);
+}

package/src/modular/emit-models-options.ts

@@ -0,0 +1,56 @@
+import * as path from "path";
+
+import { ModularEmitterOptions } from "./interfaces.js";
+
+import { SdkClientType, SdkServiceOperation } from "@azure-tools/typespec-client-generator-core";
+import { useContext } from "../context-manager.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 { buildOperationOptions } from "./build-operations.js";
+
+// ====== UTILITIES ======
+
+export function buildApiOptions(
+  context: SdkContext,
+  clientMap: [string[], SdkClientType<SdkServiceOperation>],
+  emitterOptions: ModularEmitterOptions,
+) {
+  const project = useContext("outputProject");
+  const [_, client] = clientMap;
+  const modelOptionsFiles = [];
+  const { subfolder } = getModularClientOptions(clientMap);
+  const methodMap = getMethodHierarchiesMap(context, client);
+  for (const [prefixKey, operations] of methodMap) {
+    const prefixes = prefixKey.split("/");
+    const modelOptionsFile = project.createSourceFile(
+      path.join(
+        emitterOptions.modularOptions.sourceRoot,
+        subfolder ?? "",
+        `api`,
+        ...prefixes.map((p) => normalizeName(p, NameType.File)),
+        "options.ts",
+      ),
+      undefined,
+      {
+        overwrite: true,
+      },
+    );
+    operations.forEach((o) => {
+      buildOperationOptions(context, [prefixes, o], modelOptionsFile);
+    });
+    modelOptionsFile
+      .getImportDeclarations()
+      .filter((id) => {
+        return id.isModuleSpecifierRelative() && !id.getModuleSpecifierValue().endsWith(".js");
+      })
+      .map((id) => {
+        id.setModuleSpecifier(id.getModuleSpecifierValue() + ".js");
+        return id;
+      });
+    modelOptionsFiles.push(modelOptionsFile);
+  }
+
+  return modelOptionsFiles;
+}