latest changes

packages/extensions/openapi-to-cadl/src/emiters/emit-arm-resources.ts

@@ -3,15 +3,17 @@ import { getSession } from "../autorest-session";
 import { generateArmOperations } from "../generate/generate-arm-operations";
 import { generateObject } from "../generate/generate-object";
 import { CadlProgram } from "../interfaces";
-import { ArmResourcesCache } from "../transforms/transform-resources";
+import { getAllArmResources } from "../transforms/transform-resources";
 import { formatCadlFile } from "../utils/format";
 import { getResourcesImports } from "../utils/imports";
 import { getNamespace } from "../utils/namespace";
 
 export function emitArmResources(program: CadlProgram, basePath: string) {
   // Create a file per resource
   const session = getSession();
-  for (const [_schema, armResource] of ArmResourcesCache.entries()) {
+
+  const allArmResources = getAllArmResources(session.model);
+  for (const [_schema, armResource] of allArmResources.entries()) {
     const { modules, namespaces } = getResourcesImports(program, armResource);
     const filePath = join(basePath, `${armResource.name}.tsp`);
     const generatedResource = generateObject(armResource);

packages/extensions/openapi-to-cadl/src/emiters/emit-models.ts

@@ -1,4 +1,3 @@
-import { ArmResourcesCache } from "transforms/transform-resources";
 import { getSession } from "../autorest-session";
 import { generateEnums } from "../generate/generate-enums";
 import { generateObject } from "../generate/generate-object";

packages/extensions/openapi-to-cadl/src/generate/generate-arm-operations.ts

@@ -1,19 +1,10 @@
-import {
-  ArraySchema,
-  ObjectSchema,
-  Operation,
-  Response,
-  Schema,
-  SchemaResponse,
-  isObjectSchema,
-} from "@autorest/codemodel";
-import { lowerFirst, toLower } from "lodash";
+import { ObjectSchema, Operation, isObjectSchema } from "@autorest/codemodel";
+import { lowerFirst } from "lodash";
 import { plural } from "pluralize";
 import { getSession } from "../autorest-session";
-import { CadlObject, CadlObjectProperty, CadlOperation, TypespecArmResource } from "../interfaces";
+import { CadlOperation, TypespecArmResource } from "../interfaces";
 import { transformOperation } from "../transforms/transform-operations";
-import { ArmResourcesCache, getArmResourceNames } from "../transforms/transform-resources";
-import { generateDecorators } from "../utils/decorators";
+import { getArmResourceNames } from "../transforms/transform-resources";
 import { generateDocs } from "../utils/docs";
 import { isArraySchema, isResponseSchema } from "../utils/schemas";
 import { generateParameters } from "./generate-operations";

packages/extensions/openapi-to-cadl/src/interfaces.ts

@@ -175,7 +175,7 @@ export interface InternalArmResource {
   Name: string;
   Operations: InternalArmResourceOperation[];
   Parents: string[];
-  ModelName: string;
+  SwaggerModelName: string;
   IsTrackedResource: boolean;
   IsResource: boolean;
   IsExtensionResource: boolean;

packages/extensions/openapi-to-cadl/src/main.ts

@@ -14,9 +14,10 @@ import { emitModels } from "./emiters/emit-models";
 import { emitPackage } from "./emiters/emit-package";
 import { emitRoutes } from "./emiters/emit-routes";
 import { getModel } from "./model";
+import { getOptions } from "./options";
 import { preTransformArmResources } from "./pretransforms/arm-resource-pretrasnform";
 import { pretransformNames } from "./pretransforms/name-pretransform";
-import { calculateArmResources } from "./transforms/transform-resources";
+import { getAllArmResources } from "./transforms/transform-resources";
 import { markErrorModels } from "./utils/errors";
 import { markPagination } from "./utils/paging";
 import { markResources } from "./utils/resources";
@@ -26,10 +27,11 @@ export interface ArmCodeModel extends CodeModel {
 export async function processRequest(host: AutorestExtensionHost) {
   const session = await startSession<ArmCodeModel>(host, codeModelSchema);
   setSession(session);
+  const options = getOptions();
   const codeModel = session.model;
 
   preTransformArmResources(codeModel);
-  calculateArmResources(codeModel);
+  getAllArmResources(codeModel);
   pretransformNames(codeModel);
 
   markPagination(codeModel);

packages/extensions/openapi-to-cadl/src/model.ts

@@ -4,7 +4,7 @@ import { CadlDataType, CadlProgram } from "./interfaces";
 import { transformEnum } from "./transforms/transform-choices";
 import { getCadlType, transformObject } from "./transforms/transform-object";
 import { transformOperationGroup } from "./transforms/transform-operations";
-import { ArmResourcesCache } from "./transforms/transform-resources";
+import { getAllArmResources } from "./transforms/transform-resources";
 import { transformServiceInformation } from "./transforms/transform-service-information";
 import { isChoiceSchema } from "./utils/schemas";
 
@@ -46,10 +46,10 @@ function transformModel(codeModel: CodeModel): CadlProgram {
   );
 
   let cadlObjects = codeModel.schemas.objects?.map((o) => transformObject(o, codeModel)) ?? [];
-
-  if (ArmResourcesCache.size) {
+  const armResourcesCache = getAllArmResources(codeModel);
+  if (armResourcesCache.size) {
     const armResourceNames: Set<string> = new Set();
-    for (const resource of ArmResourcesCache.values()) {
+    for (const resource of armResourcesCache.values()) {
       armResourceNames.add(resource.name);
     }
     cadlObjects = cadlObjects

packages/extensions/openapi-to-cadl/src/pretransforms/arm-resource-pretrasnform.ts

@@ -1,7 +1,7 @@
 import { dirname, join } from "path";
 import { ArmCodeModel } from "main";
 import { getSession } from "../autorest-session";
-import { ArmResourceObjectSchema, InternalArmResources } from "../interfaces";
+import { ArmResourceObjectSchema, InternalArmResource } from "../interfaces";
 
 export function preTransformArmResources(codeModel: ArmCodeModel) {
   const session = getSession();
@@ -10,11 +10,18 @@ export function preTransformArmResources(codeModel: ArmCodeModel) {
 
   const localConfigFolder = dirname(configFiles.find((c) => c.startsWith(configPath)) ?? "").replace("file://", "");
 
-  const { Resources: resources }: InternalArmResources = require(join(localConfigFolder, "resources.json"));
+  const { Resources } = require(join(localConfigFolder, "resources.json"));
+
+  const resources: InternalArmResource[] = [];
+
+  for (const resource in Resources) {
+    resources.push(Resources[resource]);
+  }
+
   codeModel.armResources = resources;
   const objectSchemas: ArmResourceObjectSchema[] = codeModel.schemas.objects ?? [];
   for (const schema of objectSchemas) {
-    const resourceInfo = resources.find((r) => r.ModelName === schema.language.default.name);
+    const resourceInfo = resources.find((r) => r.SwaggerModelName === schema.language.default.name);
     schema.resourceInformation = resourceInfo;
   }
 }

packages/extensions/openapi-to-cadl/src/transforms/transform-object.ts

@@ -22,7 +22,7 @@ import {
   isSealedChoiceSchema,
 } from "../utils/schemas";
 import { transformValue } from "../utils/values";
-import { ArmResourcesCache } from "./transform-resources";
+import { getAllArmResources } from "./transform-resources";
 
 const cadlTypes = new Map<SchemaType, string>([
   [SchemaType.Date, "plainDate"],
@@ -42,8 +42,6 @@ const cadlTypes = new Map<SchemaType, string>([
   [SchemaType.AnyObject, "object"],
 ]);
 
-const _armResources = ArmResourcesCache;
-
 export function transformObject(schema: ObjectSchema, codeModel: CodeModel): CadlObject {
   const cadlTypes = getDataTypes(codeModel);
   let visited: Partial<CadlObject> = cadlTypes.get(schema) as CadlObject;
@@ -63,7 +61,8 @@ export function transformObject(schema: ObjectSchema, codeModel: CodeModel): Cad
   visited = { name, doc };
   cadlTypes.set(schema, visited as any);
 
-  const armResource = _armResources.get(schema);
+  const allArmResources = getAllArmResources(codeModel);
+  const armResource = allArmResources.get(schema);
 
   if (armResource) {
     cadlTypes.set(schema, armResource);

packages/extensions/openapi-to-cadl/src/transforms/transform-resources.ts

@@ -6,7 +6,7 @@ import { ArmResourceKind, ArmResourceObjectSchema, CadlDecorator, TypespecArmRes
 import { isResponseSchema } from "../utils/schemas";
 
 const _resourceKinds = ["ProxyResource", "TrackedResource"];
-export const ArmResourcesCache = new Map<ObjectSchema, TypespecArmResource>();
+const ArmResourcesCache = new Map<ObjectSchema, TypespecArmResource>();
 export let ArmResourcesCacheByName: Map<string, TypespecArmResource> | undefined;
 let _armResourcesnameCache: Set<string> | undefined;
 export interface ArmResourceSchema extends ObjectSchema {
@@ -40,10 +40,10 @@ function isArmObjectSchema(schema: ObjectSchema): schema is ArmResourceObjectSch
 }
 
 function getModelName(codeModel: ArmCodeModel, resoureName: string) {
-  return codeModel.armResources?.find((r) => r.Name === resoureName)?.ModelName;
+  return codeModel.armResources?.find((r) => r.Name === resoureName)?.SwaggerModelName;
 }
 
-export function calculateArmResources(codeModel: CodeModel) {
+export function getAllArmResources(codeModel: CodeModel) {
   if (ArmResourcesCache.size) {
     return ArmResourcesCache;
   }
@@ -224,14 +224,10 @@ function getResourceKind(schema: ArmResourceObjectSchema): ArmResourceKind {
     return "TrackedResource";
   }
 
-  if (schema.resourceInformation.IsResource) {
-    return "ProxyResource";
-  }
-
   if (schema.resourceInformation.IsExtensionResource) {
     return "ExtensionResource";
   }
-  throw new Error(`Unable to determine resource kind for schema ${schema.language.default.name}`);
+  return "ProxyResource";
 }
 
 function isResourceModel(schema: ObjectSchema): schema is ArmResourceSchema {

packages/extensions/openapi-to-cadl/src/utils/imports.ts

@@ -1,5 +1,6 @@
+import { getSession } from "../autorest-session";
 import { CadlProgram, TypespecArmResource } from "../interfaces";
-import { ArmResourcesCache } from "../transforms/transform-resources";
+import { getAllArmResources } from "../transforms/transform-resources";
 
 type Imports = {
   modules: string[];
@@ -53,7 +54,9 @@ export function getModelsImports(program: CadlProgram) {
     }
   }
 
-  if (ArmResourcesCache.size) {
+  const session = getSession();
+  const allArmResources = getAllArmResources(session.model);
+  if (allArmResources.size) {
     modules.add(`import "@azure-tools/typespec-azure-resource-manager";`);
     namespaces.add(`using Azure.ResourceManager;`);
     namespaces.add(`using Azure.ResourceManager.Foundations;`);