@azure-tools/typespec-ts 0.13.0 → 0.13.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@azure-tools/typespec-ts",
-  "version": "0.13.0",
+  "version": "0.13.1",
   "description": "An experimental CADL emitter for TypeScript RLC",
   "main": "dist/src/index.js",
   "type": "module",
@@ -23,10 +23,10 @@
     "ts-node": "^10.9.1",
     "typescript": "~5.0.0",
     "prettier": "~2.7.1",
-    "@azure-tools/cadl-ranch-specs": "~0.14.10",
+    "@azure-tools/cadl-ranch-specs": "~0.15.4",
     "@typespec/versioning": "~0.44.0",
-    "@azure-tools/cadl-ranch-expect": "^0.3.0",
-    "@azure-tools/cadl-ranch": "~0.4.13",
+    "@azure-tools/cadl-ranch-expect": "^0.3.2",
+    "@azure-tools/cadl-ranch": "~0.4.17",
     "chalk": "^4.0.0",
     "@azure-rest/core-client": "^1.1.3",
     "@azure/core-auth": "^1.3.2",
@@ -47,10 +47,17 @@
   "dependencies": {
     "prettier": "^2.6.1",
     "tslib": "^2.3.1",
-    "@azure-tools/rlc-common": "^0.13.0",
+    "@azure-tools/rlc-common": "^0.13.1",
     "ts-morph": "^15.1.0",
     "fs-extra": "^11.1.0"
   },
+  "files": [
+    "src",
+    "dist/**",
+    "README.md",
+    "CHANGELOG.md",
+    "LICENSE"
+  ],
   "mocha": {
     "extension": [
       "ts"
@@ -73,11 +80,11 @@
     "check:tree": "ts-node ./test/commands/check-clean-tree.ts",
     "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",
+    "copy:typespec": "rm -rf temp && mkdirp -p temp && cp -r ./node_modules/@azure-tools/cadl-ranch-specs/http ./temp && cp -r ./test/integration/typespec/* ./temp/http",
     "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 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'"
+    "unit-test": "cross-env TS_NODE_PROJECT=tsconfig.json mocha -r ts-node/register --experimental-specifier-resolution=node --experimental-modules=true  --timeout 4000 './test/unit/**/*.spec.ts'"
   }
 }

package/src/index.ts

@@ -36,7 +36,7 @@ import {
 } from "@azure-tools/typespec-client-generator-core";
 import * as path from "path";
 import { buildSharedTypes } from "./modular/buildSharedTypes.js";
-import { Project } from "ts-morph";
+import { Project, SyntaxKind } from "ts-morph";
 import { buildClientContext } from "./modular/buildClientContext.js";
 import { emitCodeModel } from "./modular/buildCodeModel.js";
 import { buildRootIndex } from "./modular/buildRootIndex.js";
@@ -120,11 +120,12 @@ export async function $onEmit(context: EmitContext) {
       buildApiIndexFile(project, srcPath);
       buildClassicalClient(client, project, srcPath);
       buildRootIndex(client, project, srcPath);
-
       emitPackage(project, srcPath, modularCodeModel);
       emitTsConfig(project, srcPath, modularCodeModel);
     }
 
+    removeUnusedInterfaces(project);
+
     for (const file of project.getSourceFiles()) {
       await emitContentByBuilder(
         program,
@@ -136,6 +137,50 @@ export async function $onEmit(context: EmitContext) {
   }
 }
 
+function removeUnusedInterfaces(project: Project) {
+  const allInterfaces = project
+    .getSourceFiles()
+    .flatMap((file) => file.getInterfaces());
+
+  const unusedInterfaces = allInterfaces.filter((interfaceDeclaration) => {
+    const references = interfaceDeclaration
+      .findReferencesAsNodes()
+      .filter((node) => {
+        const kind = node.getParent()?.getKind();
+        return (
+          kind !== SyntaxKind.ExportSpecifier &&
+          kind !== SyntaxKind.InterfaceDeclaration
+        );
+      });
+    return references.length === 0;
+  });
+
+  unusedInterfaces.forEach((interfaceDeclaration) => {
+    const interfaceName = interfaceDeclaration.getName();
+
+    // Get the index.ts file
+    const indexFiles = project.getSourceFiles("**/index.ts"); // Adjust the path to your index.ts file
+
+    for (const indexFile of indexFiles) {
+      // Get all export declarations
+      const exportDeclarations = indexFile.getExportDeclarations();
+
+      // Iterate over each export declaration
+      exportDeclarations.forEach((exportDeclaration) => {
+        // Find named exports that match the unused interface
+        const matchingExports = exportDeclaration
+          .getNamedExports()
+          .filter((ne) => ne.getName() === interfaceName);
+
+        // Remove the matching exports
+        matchingExports.forEach((me) => me.remove());
+      });
+    }
+
+    interfaceDeclaration.remove();
+  });
+}
+
 function clearSrcFolder(
   srcPath: string,
   count: number,

package/src/modelUtils.ts

@@ -74,6 +74,60 @@ export function getBinaryType(usage: SchemaContext[]) {
     : "string | Uint8Array | ReadableStream<Uint8Array> | NodeJS.ReadableStream";
 }
 
+export function isByteOrByteUnion(
+  program: Program,
+  dpgContext: SdkContext,
+  type: Type
+) {
+  const schema = getSchemaForType(program, dpgContext, type);
+  return isByteType(schema) || isByteUnion(schema);
+}
+
+function isByteType(schema: any) {
+  return schema.type === "string" && schema.format === "byte";
+}
+
+function isByteUnion(schema: any) {
+  if (!Array.isArray(schema.enum)) {
+    return false;
+  }
+  for (const ele of schema.enum) {
+    if (isByteType(ele)) {
+      return true;
+    }
+  }
+  return false;
+}
+
+function refineByteType(schema: any) {
+  schema.typeName = getBinaryType([
+    SchemaContext.Input,
+    SchemaContext.Exception
+  ]);
+  schema.outputTypeName = getBinaryType([SchemaContext.Output]);
+  return schema;
+}
+
+export function enrichBinaryTypeInBody(schema: any) {
+  if (isByteType(schema)) {
+    refineByteType(schema);
+  } else if (isByteUnion(schema)) {
+    const inputType: string[] = [];
+    for (const item of schema.enum) {
+      if (isByteType(item)) {
+        refineByteType(item);
+      }
+      // ignore the string type for input because we already have it in bytes union
+      if (getTypeName(item, [SchemaContext.Input]) !== "string") {
+        inputType.push(getTypeName(item, [SchemaContext.Input]));
+      }
+    }
+    // refine the input type
+    schema.typeName = inputType.join(" | ");
+  }
+  return schema;
+}
+
 export function getSchemaForType(
   program: Program,
   dpgContext: SdkContext,
@@ -102,8 +156,17 @@ export function getSchemaForType(
       needRef
     ) as any;
     if (usage && usage.includes(SchemaContext.Output)) {
-      schema.outputTypeName = `${schema.name}Output`;
-      schema.typeName = `${schema.name}`;
+      if (!schema.name) {
+        //TODO: HANDLE ANONYMOUS
+        schema.outputTypeName =
+          schema.type === "object" ? "Record<string, any>" : "any";
+        schema.typeName =
+          schema.type === "object" ? "Record<string, unknown>" : "unknown";
+        schema.type = "unknown";
+      } else {
+        schema.outputTypeName = `${schema.name}Output`;
+        schema.typeName = `${schema.name}`;
+      }
     }
     schema.usage = usage;
     return schema;
@@ -169,7 +232,10 @@ function getSchemaForScalar(
   scalar: Scalar,
   relevantProperty?: ModelProperty
 ) {
-  let result = getSchemaForStdScalar(program, scalar, relevantProperty);
+  const encodeData = getEncode(program, scalar);
+  let result: any = encodeData
+    ? getSchemaForScalar(program, dpgContext, encodeData.type)
+    : getSchemaForStdScalar(program, scalar, relevantProperty);
   if (!result && scalar.baseScalar) {
     result = getSchemaForScalar(program, dpgContext, scalar.baseScalar);
   }
@@ -789,23 +855,27 @@ function mapCadlStdTypeToTypeScript(
           }
         } else {
           if (schema.items.typeName) {
-            schema.typeName = schema.items.typeName
-              .split("|")
-              .map((typeName: string) => {
-                return `${typeName}[]`;
-              })
-              .join(" | ");
-            if (
-              schema.items.outputTypeName &&
-              usage &&
-              usage.includes(SchemaContext.Output)
-            ) {
-              schema.outputTypeName = schema.items.outputTypeName
+            if (schema.items.type === "dictionary") {
+              schema.typeName = `${schema.items.typeName}[]`;
+            } else {
+              schema.typeName = schema.items.typeName
                 .split("|")
                 .map((typeName: string) => {
                   return `${typeName}[]`;
                 })
                 .join(" | ");
+              if (
+                schema.items.outputTypeName &&
+                usage &&
+                usage.includes(SchemaContext.Output)
+              ) {
+                schema.outputTypeName = schema.items.outputTypeName
+                  .split("|")
+                  .map((typeName: string) => {
+                    return `${typeName}[]`;
+                  })
+                  .join(" | ");
+              }
             }
           } else if (schema.items.type.includes("|")) {
             schema.typeName = `(${schema.items.type})[]`;
@@ -909,6 +979,11 @@ function getSchemaForStdScalar(
         type: "number",
         format: "float"
       });
+    case "float":
+      return applyIntrinsicDecorators(program, cadlType, {
+        type: "number",
+        format: "float"
+      });
     case "string":
       return applyIntrinsicDecorators(program, cadlType, {
         type: "string"

package/src/modular/buildApiIndex.ts

@@ -4,7 +4,9 @@ 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()];
+    const exports = [...file.getExportedDeclarations().keys()].filter(
+      (k) => !k.startsWith("_")
+    );
     indexFile.addExportDeclaration({
       moduleSpecifier: `./${file.getBaseNameWithoutExtension()}.js`,
       namedExports: exports

package/src/modular/buildClassicalClient.ts

@@ -27,6 +27,12 @@ export function buildClassicalClient(
   const clientFile = project.createSourceFile(
     `${srcPath}/src/${classicalClientname}.ts`
   );
+
+  clientFile.addExportDeclaration({
+    namedExports: [`${classicalClientname}Options`],
+    moduleSpecifier: `./api/${modularClientName}Context.js`
+  });
+
   const clientClass = clientFile.addClass({
     isExported: true,
     name: `${classicalClientname}`
@@ -74,7 +80,7 @@ function importAllModels(clientFile: SourceFile, srcPath: string) {
 function importCredential(clientSourceFile: SourceFile): void {
   clientSourceFile.addImportDeclaration({
     moduleSpecifier: "@azure/core-auth",
-    namedImports: ["TokenCredential", "AzureKeyCredential"]
+    namedImports: ["TokenCredential", "KeyCredential"]
   });
 }
 
@@ -119,6 +125,7 @@ function buildClientOperationGroups(
       clientClass.addMethods(
         declarations.map((d) => {
           const method: MethodDeclarationStructure = {
+            docs: d.getJsDocs().map((d) => d.getStructure()),
             name: d.getName() ?? "FIXME",
             kind: StructureKind.Method,
             returnType: d.getReturnType().getText(),
@@ -139,9 +146,4 @@ function buildClientOperationGroups(
       );
     }
   }
-  // Import ClientOptions
-  clientClass.getSourceFile().addImportDeclaration({
-    moduleSpecifier: `./common/interfaces.js`,
-    namedImports: ["ClientOptions"]
-  });
 }

package/src/modular/buildClientContext.ts

@@ -27,9 +27,17 @@ export function buildClientContext(
     moduleSpecifier: "../rest/index.js",
     namedExports: [`${client.name}Context`]
   });
-  // clientContextFile.addExportAssignment({
-  //   expression: `${client.name}Context`
-  // });
+
+  clientContextFile.addImportDeclaration({
+    moduleSpecifier: "@azure-rest/core-client",
+    namedImports: ["ClientOptions"]
+  });
+
+  clientContextFile.addInterface({
+    name: `${name}ClientOptions`,
+    isExported: true,
+    extends: ["ClientOptions"]
+  });
 
   const factoryFunction = clientContextFile.addFunction({
     docs: [description],