@azure-tools/typespec-ts 0.11.0-alpha.20230413.3

package/src/modular/buildApiIndex.ts

@@ -0,0 +1,13 @@
+import { Project } from "ts-morph";
+
+export function buildApiIndexFile(project: Project, srcPath: string) {
+  const apiFiles = project.getSourceFiles("**/src/api/**");
+  const indexFile = project.createSourceFile(`${srcPath}/src/api/index.ts`);
+  for (const file of apiFiles) {
+    const exports = [...file.getExportedDeclarations().keys()];
+    indexFile.addExportDeclaration({
+      moduleSpecifier: `./${file.getBaseNameWithoutExtension()}.js`,
+      namedExports: exports
+    });
+  }
+}

package/src/modular/buildClassicalClient.ts

@@ -0,0 +1,154 @@
+import {
+  ClassDeclaration,
+  FunctionDeclarationStructure,
+  MethodDeclarationStructure,
+  OptionalKind,
+  ParameterDeclarationStructure,
+  Project,
+  Scope,
+  SourceFile,
+  StructureKind
+} from "ts-morph";
+import { toCamelCase } from "../casingUtils.js";
+import { getClientParameters } from "./helpers/clientHelpers.js";
+import { getClientName } from "./helpers/namingHelpers.js";
+import { getOperationFunction } from "./helpers/operationHelpers.js";
+import { Client } from "./modularCodeModel.js";
+
+export function buildClassicalClient(
+  client: Client,
+  project: Project,
+  srcPath: string
+) {
+  const { description } = client;
+  const name = getClientName(client);
+  const params = getClientParameters(client);
+
+  const clientFile = project.createSourceFile(`${srcPath}/src/${name}.ts`);
+  const clientClass = clientFile.addClass({
+    isExported: true,
+    name: `${name}`
+  });
+
+  // Add the private client member. This will be the client context from /api
+  clientClass.addProperty({
+    name: "_client",
+    type: `${name}Context`,
+    scope: Scope.Private
+  });
+
+  // TODO: We may need to generate constructo overloads at some point. Here we'd do that.
+  const constructor = clientClass.addConstructor({
+    docs: [description],
+    parameters: params
+  });
+  constructor.addStatements([
+    `this._client = create${name}(${(params ?? [])
+      .map((p) => p.name)
+      .join(",")})`
+  ]);
+  importCredential(params, clientFile);
+  buildClientOperationGroups(client, clientClass);
+  importAllModels(clientFile, srcPath);
+  clientFile.fixUnusedIdentifiers();
+}
+
+function importAllModels(clientFile: SourceFile, srcPath: string) {
+  const project = clientFile.getProject();
+  const apiModels = project.getSourceFile(`${srcPath}/src/api/index.ts`);
+
+  if (!apiModels) {
+    return;
+  }
+
+  const exported = [...apiModels.getExportedDeclarations().keys()];
+
+  clientFile.addImportDeclaration({
+    moduleSpecifier: `./api/index.js`,
+    namedImports: exported
+  });
+}
+
+function importCredential(
+  params: OptionalKind<ParameterDeclarationStructure>[],
+  clientSourceFile: SourceFile
+): void {
+  const credential = params.find((p) => p.name === "credential");
+
+  if (!credential) {
+    return;
+  }
+
+  clientSourceFile.addImportDeclaration({
+    moduleSpecifier: "@azure/core-auth",
+    namedImports: [credential.type ?? "TokenCredential"]
+  });
+}
+
+function buildClientOperationGroups(
+  client: Client,
+  clientClass: ClassDeclaration
+) {
+  for (const operationGroup of client.operationGroups) {
+    const operationGroupName = toCamelCase(operationGroup.propertyName);
+    const operationDeclarations: OptionalKind<FunctionDeclarationStructure>[] =
+      operationGroup.operations.map((operation) =>
+        getOperationFunction(operation)
+      );
+
+    const tempfile = new Project().createSourceFile("temp.ts");
+
+    const declarations = tempfile.addFunctions(operationDeclarations);
+
+    if (operationGroupName) {
+      clientClass.addProperty({
+        name: operationGroupName,
+        initializer: `
+      {
+        ${declarations.map((d) => {
+          return `${d.getName()}: (${d
+            .getParameters()
+            .filter((p) => p.getName() !== "context")
+            .map((p) => p.getText())
+            .join(",")}): ${d
+            .getReturnType()
+            .getText()} => {return ${d.getName()}(${[
+            "this._client",
+            ...d.getParameters().map((p) => p.getName())
+          ]
+            .filter((p) => p !== "context")
+            .join(",")})}`;
+        })}
+      }
+      `
+      });
+    } else {
+      clientClass.addMethods(
+        declarations.map((d) => {
+          const method: MethodDeclarationStructure = {
+            name: d.getName() ?? "FIXME",
+            kind: StructureKind.Method,
+            returnType: d.getReturnType().getText(),
+            parameters: d
+              .getParameters()
+              .filter((p) => p.getName() !== "context")
+              .map((d) => d.getStructure()),
+            statements: `return ${d.getName()}(${[
+              "this._client",
+              ...d.getParameters().map((p) => p.getName())
+            ]
+              .filter((p) => p !== "context")
+              .join(",")})`
+          };
+
+          return method;
+        })
+      );
+    }
+  }
+  // Import ClientOptions
+  clientClass.getSourceFile().addImportDeclaration({
+    moduleSpecifier: `./common/interfaces.js`,
+    namedImports: ["ClientOptions"]
+  });
+}

package/src/modular/buildClientContext.ts

@@ -0,0 +1,96 @@
+import { FunctionDeclaration, Project, SourceFile } from "ts-morph";
+import { getClientParameters } from "./helpers/clientHelpers.js";
+import { importCredential } from "./helpers/credentialHelpers.js";
+import { getClientName } from "./helpers/namingHelpers.js";
+import { Client, Parameter } from "./modularCodeModel.js";
+
+/**
+ * This function creates the file containing the modular client context
+ */
+export function buildClientContext(
+  client: Client,
+  project: Project,
+  srcPath: string = "src"
+): SourceFile {
+  const { description, parameters } = client;
+  const name = getClientName(client);
+  const clientContextFile = project.createSourceFile(
+    `${srcPath}/src/api/${name}Context.ts`
+  );
+
+  clientContextFile.addExportDeclaration({
+    moduleSpecifier: "../rest/index.js",
+    namedExports: [`${name}Context`]
+  });
+
+  const factoryFunction = clientContextFile.addFunction({
+    docs: [description],
+    name: `create${name}`,
+    returnType: `${name}Context`,
+    parameters: getClientParameters(client),
+    isExported: true
+  });
+
+  const credentialsParam = parameters.find(
+    (p) => p.clientName === "credential"
+  );
+
+  const baseUrlParam: Parameter | undefined = parameters.find(
+    (p) => p.location === "endpointPath"
+  );
+
+  let baseUrl: string | undefined = "endpoint";
+  if (baseUrlParam) {
+    baseUrl =
+      baseUrlParam.type.type === "constant"
+        ? baseUrlParam.type.value
+        : baseUrlParam.clientName;
+  }
+
+  factoryFunction.addStatements([`const baseUrl = ${baseUrl}`]);
+  let getClientStatement = `const clientContext = getClient(baseUrl, options)`;
+
+  // If the client needs credentials we need to pass those to getClient
+  if (credentialsParam) {
+    importCredential(credentialsParam, clientContextFile);
+    addCredentialOptionsStatement(credentialsParam, factoryFunction);
+    getClientStatement = `const clientContext = getClient(baseUrl, credential, options)`;
+  }
+
+  factoryFunction.addStatements([getClientStatement, "return clientContext;"]);
+
+  clientContextFile.addImportDeclarations([
+    {
+      moduleSpecifier: "../rest/index.js",
+      defaultImport: "getClient"
+    }
+  ]);
+
+  clientContextFile.fixMissingImports(
+    {},
+    { importModuleSpecifierEnding: "js" }
+  );
+
+  return clientContextFile;
+}
+
+/**
+ * This function adds the statements to pass the credential to getClient
+ */
+function addCredentialOptionsStatement(
+  credential: Parameter,
+  factoryFunction: FunctionDeclaration
+): void {
+  switch (credential.type.type) {
+    case "Key":
+      if (!credential.type.policy?.key) {
+        throw new Error(`Key credential does not define a header name`);
+      }
+      factoryFunction.addStatements(
+        `options.credentials = {...options.credentials, apiKeyHeaderName: "${credential.type.policy.key}"}`
+      );
+      return;
+    default:
+      return;
+  }
+}