@azure-tools/typespec-ts 0.11.0 → 0.12.0-alpha.20230501.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@azure-tools/typespec-ts",
-  "version": "0.11.0",
+  "version": "0.12.0-alpha.20230501.1",
   "description": "An experimental CADL emitter for TypeScript RLC",
   "main": "dist/src/index.js",
   "type": "module",
@@ -14,11 +14,12 @@
     "check-format": "npm run prettier -- --check",
     "prettier": "prettier --config ./.prettierrc src/**/*.ts",
     "check:tree": "ts-node ./test/commands/check-clean-tree.ts",
-    "integration-test-ci": "npm run start-test-server & npm run generate-and-run",
+    "integration-test-ci": "npm run start-test-server & npm run copy:typespec && npm run generate-and-run",
     "start-test-server": "mkdirp -p coverage && npx cadl-ranch serve ./node_modules/@azure-tools/cadl-ranch-specs/http  --coverageFile ./coverage/cadl-ranch-coverage-typescript.json",
+    "copy:typespec": "rm -rf temp && mkdirp -p temp && cp -r ./node_modules/@azure-tools/cadl-ranch-specs/http ./temp",
     "generate-and-run": "npm run generate-cadl-only && npm run integration-test:alone && npm run stop-test-server",
     "generate-cadl-only": "ts-node ./test/commands/gen-cadl-ranch.ts",
-    "integration-test:alone": "cross-env TS_NODE_PROJECT=tsconfig.test.json mocha -r ts-node/register --experimental-specifier-resolution=node --timeout 2000 ./test/integration/*.spec.ts",
+    "integration-test:alone": "cross-env TS_NODE_PROJECT=tsconfig.test.json mocha -r ts-node/register --experimental-specifier-resolution=node --timeout 4000 ./test/integration/*.spec.ts",
     "stop-test-server": "npx cadl-ranch server stop",
     "unit-test": "cross-env TS_NODE_PROJECT=tsconfig.json mocha -r ts-node/register --experimental-specifier-resolution=node --experimental-modules=true './test/unit/**/*.spec.ts'"
   },
@@ -30,23 +31,23 @@
     "@types/node": "^18.0.0",
     "@types/prettier": "^2.6.0",
     "@types/fs-extra": "^9.0.13",
-    "@typescript-eslint/eslint-plugin": "^5.12.1",
-    "@typescript-eslint/parser": "^5.12.1",
-    "@typespec/http": "~0.42.0",
+    "@typescript-eslint/eslint-plugin": "^5.58.0",
+    "@typescript-eslint/parser": "^5.58.0",
+    "@typespec/http": "~0.43.1",
     "chai": "^4.3.6",
     "mkdirp": "^2.1.2",
     "eslint": "^8.9.0",
     "mocha": "^9.2.2",
     "rimraf": "^3.0.2",
     "ts-node": "^10.9.1",
-    "typescript": "~4.8.0",
+    "typescript": "~5.0.0",
     "prettier": "~2.7.1",
-    "@azure-tools/cadl-ranch-specs": "~0.9.0",
-    "@typespec/versioning": "~0.42.0",
-    "@azure-tools/cadl-ranch-expect": "^0.2.0",
-    "@azure-tools/cadl-ranch": "~0.4.0",
+    "@azure-tools/cadl-ranch-specs": "~0.14.2",
+    "@typespec/versioning": "~0.43.0",
+    "@azure-tools/cadl-ranch-expect": "^0.2.3",
+    "@azure-tools/cadl-ranch": "~0.4.6",
     "chalk": "^4.0.0",
-    "@azure-rest/core-client": "^1.1.0",
+    "@azure-rest/core-client": "^1.1.2",
     "@azure/core-auth": "^1.3.2",
     "cross-env": "^7.0.3",
     "@azure/core-paging": "^1.5.0",
@@ -54,20 +55,27 @@
     "@azure/core-rest-pipeline": "^1.9.2"
   },
   "dependencies": {
-    "@typespec/compiler": "~0.42.0",
-    "@azure-tools/typespec-azure-core": "~0.28.0",
-    "@typespec/rest": "~0.42.0",
+    "@typespec/compiler": "~0.43.0",
+    "@azure-tools/typespec-azure-core": "~0.29.0",
+    "@typespec/rest": "~0.43.0",
     "prettier": "^2.6.1",
     "tslib": "^2.3.1",
-    "@azure-tools/rlc-common": "^0.11.0",
+    "@azure-tools/rlc-common": "^0.12.0",
     "ts-morph": "^15.1.0",
-    "@azure-tools/typespec-client-generator-core": "~0.28.0",
-    "fs-extra": "^11.1.0"
+    "@azure-tools/typespec-client-generator-core": "~0.29.0",
+    "fs-extra": "^11.1.0",
+    "@typespec/openapi": "0.43.0",
+    "@typespec/openapi3": "0.43.0",
+    "@azure-tools/typespec-autorest": "~0.29.0"
   },
   "mocha": {
     "extension": [
       "ts"
     ],
     "loader": "ts-node/esm"
-  }
+  },
+  "bugs": {
+    "url": "https://github.com/Azure/autorest.typescript/issues"
+  },
+  "homepage": "https://github.com/Azure/autorest.typescript/tree/main/packages/typespec-ts/"
 }

package/src/casingUtils.ts

@@ -0,0 +1,48 @@
+export function toCamelCase(name: string): string {
+  let str = name;
+  // Handle snake case or dash-separated words
+  str = str.replace(/[-_]+/g, " ");
+
+  // Handle pascal case or camel case
+  str = str.replace(/([a-z])([A-Z])/g, (_match, p1, p2) => {
+    return p1 + " " + p2.toLowerCase();
+  });
+
+  // Convert to camel case
+  str = str.replace(/\s(.)/g, (_match, p1) => {
+    return p1.toUpperCase();
+  });
+
+  // Lowercase the first character
+  return str.charAt(0).toLowerCase() + str.slice(1);
+}
+
+export function camelToSnakeCase(name: string): string {
+  const camelToSnakeCaseRe = (str: string) =>
+    str
+      .replace(/\s+/g, "_")
+      .replace(/\$/g, "")
+      .replace(/-/g, "_")
+      .replace(/[A-Z]/g, (letter) => `_${letter.toLowerCase()}`);
+
+  return camelToSnakeCaseRe(name[0]!.toLowerCase() + name.slice(1));
+}
+
+export function toPascalCase(name: string): string {
+  let str = name;
+  // Handle snake case or dash-separated words
+  str = str.replace(/[-_]+/g, " ");
+
+  // Handle pascal case or camel case
+  str = str.replace(/([a-z])([A-Z])/g, (_match, p1, p2) => {
+    return p1 + " " + p2.toLowerCase();
+  });
+
+  // Convert to camel case
+  str = str.replace(/\s(.)/g, (_match, p1) => {
+    return p1.toUpperCase();
+  });
+
+  // Lowercase the first character
+  return str.charAt(0).toUpperCase() + str.slice(1);
+}

package/src/emitUtil.ts

@@ -53,10 +53,15 @@ async function emitFile(
   }
   // Format the contents if necessary
   if (isJson || isSourceCode) {
-    prettierFileContent = format(
-      prettierFileContent,
-      isJson ? prettierJSONOptions : prettierTypeScriptOptions
-    );
+    try {
+      prettierFileContent = format(
+        prettierFileContent,
+        isJson ? prettierJSONOptions : prettierTypeScriptOptions
+      );
+    } catch (e) {
+      console.error(`Failed to format file: ${filePath}`);
+      throw e;
+    }
   }
   await host.mkdirp(dirname(filePath));
   await host.writeFile(filePath, prettierFileContent);

package/src/index.ts

@@ -25,22 +25,33 @@ import {
   buildSampleTest,
   buildReadmeFile,
   buildSerializeHelper,
-  RLCOptions,
-  RLCModel
+  RLCOptions
 } from "@azure-tools/rlc-common";
 import { transformRLCModel } from "./transform/transform.js";
 import { emitContentByBuilder, emitModels } from "./emitUtil.js";
 import {
   listClients,
-  createDpgContext
+  createSdkContext
 } from "@azure-tools/typespec-client-generator-core";
 import * as path from "path";
+import { buildSharedTypes } from "./modular/buildSharedTypes.js";
+import { Project } from "ts-morph";
+import { buildClientContext } from "./modular/buildClientContext.js";
+import { emitCodeModel } from "./modular/buildCodeModel.js";
+import { buildRootIndex } from "./modular/buildRootIndex.js";
+import { buildModels } from "./modular/emitModels.js";
+import { buildOperationFiles } from "./modular/buildOperations.js";
+import { buildApiIndexFile } from "./modular/buildApiIndex.js";
+import { buildClassicalClient } from "./modular/buildClassicalClient.js";
+import { emitPackage, emitTsConfig } from "./modular/buildProjectFiles.js";
+// import { emitPackage, emitTsConfig } from "./modular/buildProjectFiles.js";
 
 export async function $onEmit(context: EmitContext) {
   const program: Program = context.program;
   const options: RLCOptions = context.options;
-  const dpgContext = createDpgContext(context);
+  const dpgContext = createSdkContext(context);
   const clients = listClients(dpgContext);
+  const srcPath: string = context.emitterOutputDir;
   let count = -1;
   for (const client of clients) {
     count++;
@@ -51,7 +62,8 @@ export async function $onEmit(context: EmitContext) {
       context.emitterOutputDir,
       dpgContext
     );
-    clearSrcFolder(rlcModels, count);
+    const pathToClear = options.isModularLibrary ? srcPath : rlcModels.srcPath;
+    clearSrcFolder(pathToClear, count, rlcModels?.options?.multiClient);
     await emitModels(rlcModels, program);
     await emitContentByBuilder(program, buildClientDefinitions, rlcModels);
     await emitContentByBuilder(program, buildResponseTypes, rlcModels);
@@ -70,10 +82,10 @@ export async function $onEmit(context: EmitContext) {
       [
         buildEsLintConfig,
         buildRollupConfig,
-        buildTsConfig,
         buildApiExtractorConfig,
+        buildReadmeFile,
         buildPackageFile,
-        buildReadmeFile
+        buildTsConfig
       ],
       rlcModels,
       context.emitterOutputDir
@@ -92,12 +104,43 @@ export async function $onEmit(context: EmitContext) {
       context.emitterOutputDir
     );
   }
+
+  if (options.isModularLibrary) {
+    // TODO: Emit modular parts of the library
+    const project = new Project();
+    const modularCodeModel = emitCodeModel(context, { casing: "camel" });
+
+    for (const client of modularCodeModel.clients) {
+      buildSharedTypes(project, srcPath);
+      buildClientContext(client, project, srcPath);
+      buildModels(modularCodeModel, project, srcPath);
+      buildOperationFiles(client, project, srcPath);
+      buildApiIndexFile(project, srcPath);
+      buildClassicalClient(client, project, srcPath);
+      buildRootIndex(client, project, srcPath);
+
+      emitPackage(project, srcPath, modularCodeModel);
+      emitTsConfig(project, srcPath, modularCodeModel);
+    }
+
+    for (const file of project.getSourceFiles()) {
+      await emitContentByBuilder(
+        program,
+        () => ({ content: file.getFullText(), path: file.getFilePath() }),
+        modularCodeModel as any
+      );
+      // emitFile(program, { content: hrlcClient.content, path: hrlcClient.path });
+    }
+  }
 }
 
-function clearSrcFolder(model: RLCModel, count: number) {
-  const srcPath = model.srcPath;
+function clearSrcFolder(
+  srcPath: string,
+  count: number,
+  isMultiClient: boolean = false
+) {
   fsextra.emptyDirSync(srcPath);
-  if (model?.options?.multiClient && count === 0) {
+  if (isMultiClient && count === 0) {
     const folderPath = path.join(
       srcPath.substring(0, srcPath.indexOf(path.sep + "src") + 4)
     );

package/src/lib.ts

@@ -70,7 +70,8 @@ export const RLCOptionsSchema: JSONSchemaType<RLCOptions> = {
       nullable: true
     },
     azureArm: { type: "boolean", nullable: true },
-    sourceFrom: { type: "string", nullable: true }
+    sourceFrom: { type: "string", nullable: true },
+    isModularLibrary: { type: "boolean", nullable: true, default: false }
   },
   required: []
 };

package/src/modelUtils.ts

@@ -27,13 +27,19 @@ import {
   isUnknownType,
   Model,
   ModelProperty,
-  Program,
   Type,
   Union,
   isNullType,
   Scalar,
   UnionVariant,
-  getProjectedName
+  getProjectedName,
+  StringLiteral,
+  BooleanLiteral,
+  NoTarget,
+  NumericLiteral,
+  Service,
+  listServices,
+  Program
 } from "@typespec/compiler";
 import { reportDiagnostic } from "./lib.js";
 import {
@@ -54,6 +60,11 @@ import {
 } from "@typespec/http";
 import { getPagedResult, isFixed } from "@azure-tools/typespec-azure-core";
 import { extractPagedMetadataNested } from "./operationUtil.js";
+import {
+  SdkContext,
+  getDefaultApiVersion,
+  isApiVersion
+} from "@azure-tools/typespec-client-generator-core";
 
 export function getBinaryType(usage: SchemaContext[]) {
   return usage.includes(SchemaContext.Output)
@@ -134,8 +145,9 @@ export function getEffectiveModelFromType(program: Program, type: Type): Type {
 export function includeDerivedModel(model: Model): boolean {
   return (
     !isTemplateDeclaration(model) &&
-    (model.templateArguments === undefined ||
-      model.templateArguments?.length === 0 ||
+    (!model.templateMapper ||
+      !model.templateMapper.args ||
+      model.templateMapper.args?.length === 0 ||
       model.derivedModels.length > 0)
   );
 }
@@ -342,12 +354,13 @@ function getSchemaForModel(
   let name = model.name;
   if (
     !overridedModelName &&
-    model.templateArguments &&
-    model.templateArguments.length > 0 &&
+    model.templateMapper &&
+    model.templateMapper.args &&
+    model.templateMapper.args.length > 0 &&
     getPagedResult(program, model)
   ) {
     name =
-      model.templateArguments
+      model.templateMapper.args
         .map((it) => {
           switch (it.kind) {
             case "Model":
@@ -387,8 +400,8 @@ function getSchemaForModel(
     const paged = extractPagedMetadataNested(program, model);
     if (paged && paged.itemsProperty) {
       const items = paged.itemsProperty as unknown as Model;
-      if (items && items.templateArguments) {
-        const templateName = items.templateArguments
+      if (items && items.templateMapper && items.templateMapper.args) {
+        const templateName = items.templateMapper.args
           ?.map((it) => {
             switch (it.kind) {
               case "Model":
@@ -528,8 +541,9 @@ function getSchemaForModel(
   // templated type.
   if (
     model.baseModel &&
-    model.baseModel.templateArguments &&
-    model.baseModel.templateArguments.length > 0 &&
+    model.baseModel.templateMapper &&
+    model.baseModel.templateMapper.args &&
+    model.baseModel.templateMapper.args.length > 0 &&
     modelSchema.properties &&
     Object.keys(modelSchema.properties).length === 0
   ) {
@@ -845,7 +859,7 @@ function getSchemaForStdScalar(program: Program, cadlType: Scalar) {
         typeName: "Date | string",
         outputTypeName: "string"
       };
-    case "zonedDateTime":
+    case "utcDateTime":
       return {
         type: "string",
         format: "date-time",
@@ -941,8 +955,9 @@ export function getBodyType(
           // response body type is reosurce type, and request body type (if templated) contains resource type
           if (
             bodyTypeInResponse === resourceType &&
-            bodyModel.templateArguments &&
-            bodyModel.templateArguments.some((it) => {
+            bodyModel.templateMapper &&
+            bodyModel.templateMapper.args &&
+            bodyModel.templateMapper.args.some((it) => {
               return it.kind === "Model" || it.kind === "Union"
                 ? it === bodyTypeInResponse
                 : false;
@@ -959,3 +974,111 @@ export function getBodyType(
   }
   return bodyModel;
 }
+
+/**
+ * Predict if the default value exists in param, we would follow the rules:
+ * 1. If we have specific default literal in param
+ * 2. If we take the default api-version value into considerations
+ * @param program
+ * @param dpgContext
+ * @param param The param to predict
+ * @returns
+ */
+export function predictDefaultValue(
+  program: Program,
+  dpgContext: SdkContext,
+  param?: ModelProperty
+) {
+  if (!param) {
+    return;
+  }
+  const specificDefault = param?.default;
+  if (isLiteralValue(specificDefault)) {
+    return specificDefault.value;
+  }
+  const serviceNamespace = getDefaultService(program)?.type;
+  if (!serviceNamespace) {
+    return;
+  }
+  const defaultApiVersion = getEnrichedDefaultApiVersion(program, dpgContext);
+  if (param && isApiVersion(dpgContext, param) && defaultApiVersion) {
+    return defaultApiVersion;
+  }
+  return;
+}
+
+function isLiteralValue(
+  type?: Type
+): type is StringLiteral | NumericLiteral | BooleanLiteral {
+  if (!type) {
+    return false;
+  }
+
+  if (
+    type.kind === "Boolean" ||
+    type.kind === "String" ||
+    type.kind === "Number"
+  ) {
+    return type.value !== undefined;
+  }
+
+  return false;
+}
+
+export function getDefaultService(program: Program): Service | undefined {
+  const services = listServices(program);
+  if (!services || services.length === 0) {
+    reportDiagnostic(program, {
+      code: "no-service-defined",
+      target: NoTarget
+    });
+  }
+  if (services.length > 1) {
+    reportDiagnostic(program, {
+      code: "more-than-one-service",
+      target: NoTarget
+    });
+  }
+  return services[0];
+}
+
+/**
+ * Get the default api-version both from versioned and service decorator
+ * TODO: remember to switch to TCGC once the fix is done
+ * @param program
+ * @param dpgContext
+ * @returns default api-version value
+ */
+export function getEnrichedDefaultApiVersion(
+  program: Program,
+  dpgContext: SdkContext
+): string | undefined {
+  const serviceNamespace = getDefaultService(program);
+  if (!serviceNamespace) {
+    return;
+  }
+
+  const defaultVersion = getDefaultApiVersion(
+    dpgContext,
+    serviceNamespace!.type
+  );
+  if (defaultVersion) {
+    return defaultVersion.value;
+  }
+  return serviceNamespace.version;
+}
+
+export function trimUsage(model: any) {
+  if (typeof model !== "object") {
+    return model;
+  }
+  const tmpModel = Object.assign({}, model);
+  const tmpModelKeys = Object.keys(tmpModel).filter((item) => {
+    return item !== "usage";
+  });
+  const ordered = tmpModelKeys.sort().reduce((obj, key) => {
+    (obj as any)[key] = trimUsage(tmpModel[key]);
+    return obj;
+  }, {});
+  return ordered;
+}

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,147 @@
+import {
+  ClassDeclaration,
+  FunctionDeclarationStructure,
+  MethodDeclarationStructure,
+  OptionalKind,
+  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 modularClientName = getClientName(client);
+  const classicalClientname = `${getClientName(client)}Client`;
+  const params = getClientParameters(client);
+
+  const clientFile = project.createSourceFile(
+    `${srcPath}/src/${classicalClientname}.ts`
+  );
+  const clientClass = clientFile.addClass({
+    isExported: true,
+    name: `${classicalClientname}`
+  });
+
+  // Add the private client member. This will be the client context from /api
+  clientClass.addProperty({
+    name: "_client",
+    type: `${modularClientName}Context`,
+    scope: Scope.Private
+  });
+
+  // TODO: We may need to generate constructor overloads at some point. Here we'd do that.
+  const constructor = clientClass.addConstructor({
+    docs: [description],
+    parameters: params
+  });
+  constructor.addStatements([
+    `this._client = create${modularClientName}(${(params ?? [])
+      .map((p) => p.name)
+      .join(",")})`
+  ]);
+  importCredential(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(clientSourceFile: SourceFile): void {
+  clientSourceFile.addImportDeclaration({
+    moduleSpecifier: "@azure/core-auth",
+    namedImports: ["TokenCredential", "AzureKeyCredential"]
+  });
+}
+
+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"]
+  });
+}