@azure-tools/typespec-ts 0.13.0 → 0.13.1-alpha.20230609.1

package/src/modular/buildOperations.ts

@@ -2,6 +2,8 @@ import { Project, SourceFile } from "ts-morph";
 import { buildType } from "./helpers/typeHelpers.js";
 import {
   getOperationFunction,
+  getSendPrivateFunction,
+  getDeserializePrivateFunction,
   getOperationOptionsName
 } from "./helpers/operationHelpers.js";
 import { Client, Operation } from "./modularCodeModel.js";
@@ -30,7 +32,13 @@ export function buildOperationFiles(
     operationGroup.operations.forEach((o) => {
       buildOperationOptions(o, operationGroupFile);
       const operationDeclaration = getOperationFunction(o);
-      operationGroupFile.addFunction(operationDeclaration);
+      const sendOperationDeclaration = getSendPrivateFunction(o);
+      const deserializeOperationDeclaration = getDeserializePrivateFunction(o);
+      operationGroupFile.addFunctions([
+        sendOperationDeclaration,
+        deserializeOperationDeclaration,
+        operationDeclaration
+      ]);
     });
 
     operationGroupFile.addImportDeclarations([
@@ -40,6 +48,20 @@ export function buildOperationFiles(
       }
     ]);
 
+    operationGroupFile.addImportDeclarations([
+      {
+        moduleSpecifier: "../common/interfaces.js",
+        namedImports: ["OperationRawReturnType"]
+      }
+    ]);
+
+    operationGroupFile.addImportDeclarations([
+      {
+        moduleSpecifier: "@azure-rest/core-client",
+        namedImports: ["StreamableMethod"]
+      }
+    ]);
+
     // Import models used from ./models.ts
     importModels(operationGroupFile, project);
     operationGroupFile.fixMissingImports();

package/src/modular/buildRootIndex.ts

@@ -27,7 +27,7 @@ export function buildRootIndex(
   file.addExportDeclarations([
     {
       moduleSpecifier: `./common/interfaces.js`,
-      namedExports: [`ClientOptions`, `RequestOptions`]
+      namedExports: [`RequestOptions`]
     }
   ]);
 }
@@ -35,7 +35,7 @@ export function buildRootIndex(
 function exportClassicalClient(client: Client, indexFile: SourceFile) {
   const clientName = `${getClientName(client)}Client`;
   indexFile.addExportDeclaration({
-    namedExports: [clientName],
+    namedExports: [clientName, `${clientName}Options`],
     moduleSpecifier: `./${clientName}.js`
   });
 }

package/src/modular/buildSharedTypes.ts

@@ -1,22 +1,20 @@
 import { Project, SourceFile } from "ts-morph";
 
-const content = `import { ClientOptions as RestClientOptions } from "@azure-rest/core-client";
+const content = `
 import { RawHttpHeadersInput } from "@azure/core-rest-pipeline";
-export interface ClientOptions extends RestClientOptions {}
+ 
+/**
+ * Common options to set on an outgoing operation
+ */
 export interface RequestOptions {
+/**
+ * Options to set on an outgoing HTTP request
+ */
   requestOptions?: {
     /**
      * Headers to send along with the request
      */
     headers?: RawHttpHeadersInput;
-    /**
-     * Body to send with the request
-     */
-    body?: unknown;
-    /**
-     * Query parameters to send with the request
-     */
-    queryParameters?: Record<string, unknown>;
     /** Set to true if the request is sent over HTTP instead of HTTPS */
     allowInsecureConnection?: boolean;
     /** Set to true if you want to skip encoding the path parameters */

package/src/modular/emitModels.ts

@@ -17,6 +17,16 @@ export function buildModels(
     (t) => t.type === "model" || t.type === "enum"
   );
 
+  for (const model of codeModel.types) {
+    if (model.type === "combined" && model.nullable) {
+      for (const unionModel of model.types ?? []) {
+        if (unionModel.type === "model") {
+          models.push(unionModel);
+        }
+      }
+    }
+  }
+
   for (const model of models) {
     const properties = model.properties ?? [];
     const typeMetadata = getType(model);
@@ -25,6 +35,10 @@ export function buildModels(
       typeName = `${typeName}[]`;
     }
     if (model.type === "enum") {
+      if (modelsFile.getTypeAlias(model.name!)) {
+        // If the enum is already defined, we don't need to do anything
+        continue;
+      }
       modelsFile.addTypeAlias({
         name: model.name!,
         isExported: true,

package/src/modular/helpers/clientHelpers.ts

@@ -6,22 +6,12 @@ export function getClientParameters(
   client: Client
 ): OptionalKind<ParameterDeclarationStructure>[] {
   const { name, parameters } = client;
-  let optionsParam = {
+  const optionsParam = {
     name: "options",
-    type: `${name}Options`,
+    type: `${name}ClientOptions`,
     initializer: "{}"
   };
-  if (
-    !client.parameters
-      .filter((p) => p.implementation === "Client" && !p.isApiVersion)
-      .some((p) => p.optional || (!p.optional && p.clientDefaultValue))
-  ) {
-    optionsParam = {
-      name: "options",
-      type: `ClientOptions`,
-      initializer: "{}"
-    };
-  }
+
   const params: OptionalKind<ParameterDeclarationStructure>[] = [
     ...parameters
       .filter((p) => p.type.type !== "constant")

package/src/modular/helpers/credentialHelpers.ts

@@ -12,7 +12,7 @@ export function importCredential(
     case "Key":
       clientSourceFile.addImportDeclaration({
         moduleSpecifier: "@azure/core-auth",
-        namedImports: ["AzureKeyCredential"]
+        namedImports: ["KeyCredential"]
       });
       return;
     case "OAuth2":

package/src/modular/helpers/fixmeHelpers.ts

@@ -0,0 +1,3 @@
+export function getFixmeForMultilineDocs(fixme: string[]): string[] {
+  return fixme.map((fixme) => ` @fixme ${fixme}`);
+}

package/src/modular/helpers/namingHelpers.ts

@@ -1,5 +1,39 @@
-import { Client } from "../modularCodeModel.js";
+import { toCamelCase, toPascalCase } from "../../casingUtils.js";
+import { Client, Operation } from "../modularCodeModel.js";
+import { ReservedModelNames, NameType, normalizeName } from "@azure-tools/rlc-common";
 
 export function getClientName(client: Client) {
   return client.name.replace(/Client$/, "");
 }
+
+export interface GuardedName {
+  name: string;
+  fixme?: string[];
+}
+
+export function getOperationName(
+  operation: Operation,
+  options: { casing: "camel" | "pascal" } = { casing: "camel" }
+): GuardedName {
+  const casingFn = options.casing === "camel" ? toCamelCase : toPascalCase;
+  if (isReservedName(operation.name, NameType.Operation)) {
+    return {
+      name: normalizeName(operation.name, NameType.Operation, true),
+      fixme: [
+        `${operation.name} is a reserved word that cannot be used as an operation name. Please add @projectedName(
+      "javascript", "<JS-Specific-Name>") to the operation to override the generated name.`
+      ]
+    };
+  }
+
+  return {
+    name: casingFn(operation.name)
+  };
+}
+
+export function isReservedName(name: string, nameType: NameType): boolean {
+  return ReservedModelNames.some(
+    (reservedName) =>
+      reservedName.name === name && reservedName.reservedFor.includes(nameType)
+  );
+}

package/src/modular/helpers/operationHelpers.ts

@@ -12,85 +12,186 @@ import {
   Type
 } from "../modularCodeModel.js";
 import { buildType } from "./typeHelpers.js";
+import { getOperationName } from "./namingHelpers.js";
+import { getFixmeForMultilineDocs } from "./fixmeHelpers.js";
 
-/**
- * This operation builds and returns the function declaration for an operation.
- */
-export function getOperationFunction(
+function getRLCResponseType(operation: Operation) {
+  const { name } = getOperationName(operation, { casing: "pascal" });
+  const statusCodes: (string | number)[] = Array.from(
+    new Set(operation.responses.flatMap((r) => r.statusCodes)).values()
+  );
+
+  statusCodes.push("Default");
+
+  return statusCodes.map((s) => `${name}${s}Response`).join(" | ");
+}
+
+export function getSendPrivateFunction(
   operation: Operation
 ): OptionalKind<FunctionDeclarationStructure> {
-  const optionsType = getOperationOptionsName(operation);
-  // Extract required parameters
-  let parameters: OptionalKind<ParameterDeclarationStructure>[] = [];
+  const parameters = getOperationSignatureParameters(operation);
+  const { name } = getOperationName(operation);
 
+  const functionStatement: OptionalKind<FunctionDeclarationStructure> = {
+    isAsync: false,
+    isExported: true,
+    name: `_${name}Send`,
+    parameters,
+    returnType: `StreamableMethod<${getRLCResponseType(operation)}>`
+  };
+
+  const operationPath = operation.url;
+  const operationMethod = operation.method.toLowerCase();
+
+  const statements: string[] = [];
+  statements.push(
+    `return context.path("${operationPath}", ${getPathParameters(
+      operation
+    )}).${operationMethod}({allowInsecureConnection: options.requestOptions?.allowInsecureConnection, skipUrlEncoding: options.requestOptions?.skipUrlEncoding, ${getRequestParameters(
+      operation
+    )}});`
+  );
+
+  return {
+    ...functionStatement,
+    statements
+  };
+}
+
+export function getDeserializePrivateFunction(
+  operation: Operation
+): OptionalKind<FunctionDeclarationStructure> {
+  const { name } = getOperationName(operation);
+
+  const parameters: OptionalKind<ParameterDeclarationStructure>[] = [
+    {
+      name: "result",
+      type: getRLCResponseType(operation)
+    }
+  ];
+
+  // TODO: Support operation overloads
+  const response = operation.responses[0]!;
+  const returnType = response?.type?.type
+    ? buildType(response.type.name, response.type)
+    : { name: "", type: "void" };
+
+  const functionStatement: OptionalKind<FunctionDeclarationStructure> = {
+    isAsync: true,
+    isExported: true,
+    name: `_${name}Deserialize`,
+    parameters,
+    returnType: `Promise<${returnType.type}>`
+  };
+  const statements: string[] = [];
+  statements.push(`if(isUnexpected(result)){`, "throw result.body", "}");
+
+  if (response?.type?.type === "any") {
+    statements.push(`return result.body`);
+  } else if (response?.type?.elementType) {
+    statements.push(
+      `return ${deserializeResponseValue(response.type, "result.body")}`
+    );
+  } else if (response?.type?.properties) {
+    statements.push(
+      `return {`,
+      getResponseMapping(response.type.properties ?? []).join(","),
+      `}`
+    );
+  } else if (returnType.type === "void") {
+    statements.push(`return;`);
+  } else {
+    statements.push(`return result.body;`);
+  }
+  return {
+    ...functionStatement,
+    statements
+  };
+}
+
+function getOperationSignatureParameters(
+  operation: Operation
+): OptionalKind<ParameterDeclarationStructure>[] {
+  const optionsType = getOperationOptionsName(operation);
+  const parameters: Map<
+    string,
+    OptionalKind<ParameterDeclarationStructure>
+  > = new Map();
   if (operation.bodyParameter?.type.type === "model") {
-    parameters = (operation.bodyParameter?.type.properties ?? [])
+    (operation.bodyParameter?.type.properties ?? [])
       .filter((p) => !p.optional)
-      .map((p) => buildType(p.clientName, p.type));
+      .filter((p) => !p.readonly)
+      .map((p) => buildType(p.clientName, p.type))
+      .forEach((p) => parameters.set(p.name, p));
   } else if (operation.bodyParameter?.type.type === "list") {
     const bodyArray = operation.bodyParameter;
-    parameters.push(buildType(bodyArray.clientName, bodyArray.type));
+    parameters.set(
+      bodyArray.clientName,
+      buildType(bodyArray.clientName, bodyArray.type)
+    );
   }
 
-  parameters = parameters.concat(
-    operation.parameters
-      .filter(
-        (p) =>
-          p.implementation === "Method" &&
-          p.type.type !== "constant" &&
-          p.clientDefaultValue === undefined &&
-          !p.optional
-      )
-      .map((p) => buildType(p.clientName, p.type))
-  );
+  operation.parameters
+    .filter(
+      (p) =>
+        p.implementation === "Method" &&
+        p.type.type !== "constant" &&
+        p.clientDefaultValue === undefined &&
+        !p.optional
+    )
+    .map((p) => buildType(p.clientName, p.type))
+    .forEach((p) => {
+      parameters.set(p.name, p);
+    });
 
   // Add context as the first parameter
-  parameters.unshift({ name: "context", type: "Client" });
+  const contextParam = { name: "context", type: "Client" };
 
   // Add the options parameter
-  parameters.push({
+  const optionsParam = {
     name: "options",
     type: optionsType,
     initializer: "{ requestOptions: {} }"
-  });
+  };
+
+  const finalParameters = [contextParam, ...parameters.values(), optionsParam];
+
+  return finalParameters;
+}
+
+/**
+ * This operation builds and returns the function declaration for an operation.
+ */
+export function getOperationFunction(
+  operation: Operation
+): OptionalKind<FunctionDeclarationStructure> {
+  // Extract required parameters
+  const parameters: OptionalKind<ParameterDeclarationStructure>[] =
+    getOperationSignatureParameters(operation);
 
   // TODO: Support operation overloads
   const response = operation.responses[0]!;
-  const returnType =
-    response?.type?.type === "model"
-      ? buildType(response.type.name, response.type)
-      : { name: "", type: "void" };
+  const returnType = response?.type?.type
+    ? buildType(response.type.name, response.type)
+    : { name: "", type: "void" };
 
+  const { name, fixme = [] } = getOperationName(operation);
   const functionStatement: OptionalKind<FunctionDeclarationStructure> = {
-    docs: [operation.description],
+    docs: [operation.description, ...getFixmeForMultilineDocs(fixme)],
     isAsync: true,
     isExported: true,
-    name: operation.name,
+    name: name,
     parameters,
     returnType: `Promise<${returnType.type}>`
   };
 
-  const operationPath = operation.url;
-  const operationMethod = operation.method.toLowerCase();
-
   const statements: string[] = [];
   statements.push(
-    `const result = await context.path("${operationPath}", ${getPathParameters(
-      operation
-    )}).${operationMethod}({${getRequestParameters(operation)}});`
+    `const result = await _${name}Send(${parameters
+      .map((p) => p.name)
+      .join(", ")});`
   );
-
-  statements.push(`if(isUnexpected(result)){`, "throw result.body", "}");
-
-  if (!response?.type?.properties) {
-    statements.push(`return;`);
-  } else {
-    statements.push(
-      `return {`,
-      getResponseMapping(response.type.properties ?? []).join(","),
-      `}`
-    );
-  }
+  statements.push(`return _${name}Deserialize(result);`);
   return {
     ...functionStatement,
     statements
@@ -140,11 +241,11 @@ function getRequestParameters(operation: Operation): string {
     paramStr = `${getContentTypeValue(contentTypeParameter)},`;
   }
 
-  if (parametersImplementation.header.length) {
-    paramStr = `${paramStr}\nheaders: {${parametersImplementation.header.join(
-      ",\n"
-    )}, ...options.requestOptions?.headers},`;
-  }
+  paramStr = `${paramStr}\nheaders: {${
+    parametersImplementation.header.length
+      ? parametersImplementation.header.join(",\n") + ","
+      : ""
+  } ...options.requestOptions?.headers},`;
 
   if (parametersImplementation.query.length) {
     paramStr = `${paramStr}\nqueryParameters: {${parametersImplementation.query.join(
@@ -273,7 +374,7 @@ function isOptionalWithouDefault(
   return Boolean(param.optional && !param.clientDefaultValue);
 }
 function getOptionalWithoutDefault(param: OptionalWithoutDefaultType) {
-  return `...(options.${param.clientName} && {"${param.restApiName}": options.${param.clientName}})`;
+  return `"${param.restApiName}": options?.${param.clientName}`;
 }
 
 type OptionalWithDefaultType = (Parameter | Property) & {
@@ -341,6 +442,13 @@ function getPathParameters(operation: Operation) {
   return pathParams;
 }
 
+function getNullableCheck(name: string, type: Type) {
+  if (!type.nullable) {
+    return "";
+  }
+
+  return `${name} === null ? null :`;
+}
 /**
  * This function helps translating an RLC response to an HLC response,
  * extracting properties from body and headers and building the HLC response object
@@ -352,19 +460,18 @@ function getResponseMapping(
   const props: string[] = [];
   for (const property of properties) {
     // TODO: Do we need to also add headers in the result type?
+    const propertyFullName = `${propertyPath}.${property.clientName}`;
     if (property.type.type === "model") {
-      props.push(
-        `"${property.restApiName}": ${
-          !property.optional
-            ? ""
-            : `!${propertyPath}.${property.clientName} ? undefined :`
-        } {${getResponseMapping(
-          property.type.properties ?? [],
-          `${propertyPath}.${property.restApiName}${
-            property.optional ? "?" : ""
-          }`
-        )}}`
-      );
+      const definition = `"${property.restApiName}": ${getNullableCheck(
+        propertyFullName,
+        property.type
+      )} ${
+        !property.optional ? "" : `!${propertyFullName} ? undefined :`
+      } {${getResponseMapping(
+        property.type.properties ?? [],
+        `${propertyPath}.${property.restApiName}${property.optional ? "?" : ""}`
+      )}}`;
+      props.push(definition);
     } else {
       const dot = propertyPath.endsWith("?") ? "." : "";
       const restValue = `${

package/src/modular/helpers/parameterHelpers.ts

@@ -1,7 +1,7 @@
 import { Parameter } from "../modularCodeModel.js";
 
 const parameterTypeMap: Record<string, string> = {
-  Key: "AzureKeyCredential",
+  Key: "KeyCredential",
   OAuth2: "TokenCredential"
 };
 

package/src/modular/helpers/typeHelpers.ts

@@ -7,41 +7,52 @@ export interface TypeMetadata {
   modifier?: "Array";
 }
 
+function getNullableType(name: string, type: Type): string {
+  if (type.nullable) {
+    return `(${name} | null)`;
+  }
+
+  return name;
+}
+
 export function getType(type: Type): TypeMetadata {
   switch (type.type) {
     case "Key":
       return {
-        name: "AzureKeyCredential",
+        name: "KeyCredential",
         originModule: "@azure/core-auth",
         isRelative: false
       };
     case "boolean":
-      return { name: "boolean" };
+      return { name: getNullableType(type.type, type) };
     case "constant": {
       let typeName: string = type.value ?? "undefined";
       if (type.valueType?.type === "string") {
         typeName = type.value ? `"${type.value}"` : "undefined";
       }
-      return { name: typeName };
+      return { name: getNullableType(typeName, type) };
     }
     case "datetime":
-      return { name: "Date" };
+      return { name: getNullableType("Date", type) };
     case "enum":
       if (!type.name) {
         throw new Error("Unable to process enum without name");
       }
-      return { name: type.name, originModule: "models.js" };
+      return {
+        name: getNullableType(type.name, type),
+        originModule: "models.js"
+      };
     case "float":
     case "integer":
-      return { name: "number" };
+      return { name: getNullableType("number", type) };
     case "byte-array":
-      return { name: "string" };
+      return { name: getNullableType("Uint8Array", type) };
     case "list":
       if (!type.elementType) {
         throw new Error("Unable to process Array with no elementType");
       }
       return {
-        name: getType(type.elementType).name,
+        name: getNullableType(getType(type.elementType).name, type),
         modifier: "Array",
         originModule:
           type.elementType?.type === "model" ? "models.js" : undefined
@@ -50,10 +61,13 @@ export function getType(type: Type): TypeMetadata {
       if (!type.name) {
         throw new Error("Unable to process model without name");
       }
-      return { name: type.name, originModule: "models.js" };
+      return {
+        name: getNullableType(type.name, type),
+        originModule: "models.js"
+      };
     case "string":
     case "duration":
-      return { name: "string" };
+      return { name: getNullableType("string", type) };
     case "combined": {
       if (!type.types) {
         throw new Error("Unable to process combined without combinedTypes");
@@ -64,7 +78,7 @@ export function getType(type: Type): TypeMetadata {
           return `${sdkType}`;
         })
         .join(" | ");
-      return { name };
+      return { name: getNullableType(name, type) };
     }
     case "dict":
       if (!type.elementType) {
@@ -73,8 +87,15 @@ export function getType(type: Type): TypeMetadata {
       return {
         name: `Record<string, ${getTypeName(getType(type.elementType))}>`
       };
+    case "any":
+      return {
+        name: `Record<string, any>`
+      };
     default:
-      throw new Error(`Unsupported type ${type.type}`);
+      // throw new Error(`Unsupported type ${type.type}`);
+      return {
+        name: `any`
+      };
   }
 }
 

package/src/modular/modularCodeModel.ts

@@ -52,6 +52,7 @@ export interface EnumValue {
   description: string;
 }
 export interface Type {
+  nullable?: boolean;
   name?: string;
   description?: string;
   type:
@@ -70,7 +71,8 @@ export interface Type {
     | "float"
     | "boolean"
     | "dict"
-    | "combined";
+    | "combined"
+    | "any";
   policy?: Policy;
   apiVersions?: any[];
   clientDefaultValue?: any;