@typespec/http-server-csharp 0.58.0-alpha.15-dev.0 → 0.58.0-alpha.15-dev.1

package/dist/src/lib/service.js

@@ -1,5 +1,5 @@
 import { CodeTypeEmitter, StringBuilder, code, createAssetEmitter, } from "@typespec/asset-emitter";
-import { getDoc, getNamespaceFullName, getService, isErrorModel, isNeverType, isNullType, isTemplateDeclaration, isVoidType, resolvePath, serializeValueAsJson, } from "@typespec/compiler";
+import { getDoc, getNamespaceFullName, getService, isErrorModel, isNeverType, isNullType, isNumericType, isTemplateDeclaration, isVoidType, resolvePath, serializeValueAsJson, } from "@typespec/compiler";
 import { createRekeyableMap } from "@typespec/compiler/utils";
 import { getHeaderFieldName, getHttpOperation, getHttpPart, isHeader, isStatusCode, } from "@typespec/http";
 import { getResourceOperation } from "@typespec/rest";
@@ -8,12 +8,12 @@ import path from "path";
 import { getEncodedNameAttribute } from "./attributes.js";
 import { GeneratedFileHeader, GeneratedFileHeaderWithNullable, getSerializationSourceFiles, } from "./boilerplate.js";
 import { getProjectDocs } from "./doc.js";
-import { CSharpSourceType, CSharpType, NameCasingType, } from "./interfaces.js";
+import { CSharpSourceType, CSharpType, NameCasingType, checkOrAddNamespaceToScope, } from "./interfaces.js";
 import { reportDiagnostic } from "./lib.js";
 import { getProjectHelpers } from "./project.js";
 import { getBusinessLogicImplementations, getScaffoldingHelpers, } from "./scaffolding.js";
 import { getEnumType, getRecordType, isKnownReferenceType } from "./type-helpers.js";
-import { CSharpOperationHelpers, HttpMetadata, ModelInfo, UnknownType, coalesceTypes, coalesceUnionTypes, ensureCSharpIdentifier, ensureCleanDirectory, formatComment, getBusinessLogicCallParameters, getBusinessLogicDeclParameters, getCSharpIdentifier, getCSharpStatusCode, getCSharpType, getCSharpTypeForIntrinsic, getCSharpTypeForScalar, getFreePort, getHttpDeclParameters, getModelAttributes, getModelDeclarationName, getModelInstantiationName, getOpenApiConfig, getOperationVerbDecorator, getStatusCode, isEmptyResponseModel, isValueType, } from "./utils.js";
+import { CSharpOperationHelpers, HttpMetadata, ModelInfo, UnknownType, coalesceTypes, coalesceUnionTypes, ensureCSharpIdentifier, ensureCleanDirectory, formatComment, getBusinessLogicCallParameters, getBusinessLogicDeclParameters, getCSharpIdentifier, getCSharpStatusCode, getCSharpType, getCSharpTypeForIntrinsic, getCSharpTypeForScalar, getFreePort, getHttpDeclParameters, getImports, getModelAttributes, getModelDeclarationName, getModelInstantiationName, getOpenApiConfig, getOperationVerbDecorator, getStatusCode, isEmptyResponseModel, isRecord, isStringEnumType, isValueType, } from "./utils.js";
 export async function $onEmit(context) {
     let _unionCounter = 0;
     const controllers = new Map();
@@ -27,7 +27,8 @@ export async function $onEmit(context) {
         #generatedFileHeaderWithNullable = GeneratedFileHeaderWithNullable;
         #generatedFileHeader = GeneratedFileHeader;
         #sourceTypeKey = "sourceType";
-        #baseNamespace = undefined;
+        #nsKey = "ResolvedNamespace";
+        #namespaces = new Map();
         #emitterOutputType = context.options["output-type"];
         #emitMocks = context.options["emit-mocks"];
         #useSwagger = context.options["use-swaggerui"] || false;
@@ -35,14 +36,81 @@ export async function $onEmit(context) {
         #mockRegistrations = new Map();
         #opHelpers = new CSharpOperationHelpers(this.emitter);
         #fileExists = getFileWriter(this.emitter.getProgram());
+        #getOrAddNamespaceForType(type) {
+            const program = this.emitter.getProgram();
+            switch (type.kind) {
+                case "Boolean":
+                case "String":
+                case "StringTemplate":
+                case "Number":
+                case "Scalar":
+                case "Intrinsic":
+                case "FunctionParameter":
+                case "ScalarConstructor":
+                case "StringTemplateSpan":
+                case "TemplateParameter":
+                case "Tuple":
+                    return undefined;
+                case "EnumMember":
+                    return this.#getOrAddNamespaceForType(type.enum);
+                case "ModelProperty":
+                case "UnionVariant":
+                    return this.#getOrAddNamespaceForType(type.type);
+                case "Model":
+                    if (isRecord(type) && type.indexer)
+                        return this.#getOrAddNamespaceForType(type.indexer.value);
+                    if (type.indexer !== undefined && isNumericType(program, type.indexer?.key))
+                        return this.#getOrAddNamespaceForType(type.indexer.value);
+                    return this.#getOrAddNamespace(type.namespace);
+                case "Union":
+                    if (isStringEnumType(program, type))
+                        return this.#getOrAddNamespace(type.namespace);
+                    const unionType = this.#coalesceTsUnion(type);
+                    if (unionType === undefined)
+                        return undefined;
+                    return this.#getOrAddNamespaceForType(unionType);
+                default:
+                    return this.#getOrAddNamespace(type.namespace);
+            }
+        }
+        #coalesceTsUnion(union) {
+            let result = undefined;
+            for (const [_, variant] of union.variants) {
+                if (!isNullType(variant.type)) {
+                    if (result !== undefined && result !== variant.type)
+                        return undefined;
+                    result = variant.type;
+                }
+            }
+            return result;
+        }
+        #getOrAddNamespace(typespecNamespace) {
+            if (!typespecNamespace?.name)
+                return this.#getDefaultNamespace();
+            let resolvedNamespace = this.#namespaces.get(typespecNamespace);
+            if (resolvedNamespace !== undefined)
+                return resolvedNamespace;
+            const nsName = getNamespaceFullName(typespecNamespace);
+            resolvedNamespace = ensureCSharpIdentifier(this.emitter.getProgram(), typespecNamespace, nsName, NameCasingType.Namespace);
+            this.#namespaces.set(typespecNamespace, resolvedNamespace);
+            return resolvedNamespace;
+        }
+        #getDefaultNamespace() {
+            return "TypeSpec.Service";
+        }
         arrayDeclaration(array, name, elementType) {
             return this.emitter.result.declaration(ensureCSharpIdentifier(this.emitter.getProgram(), array, name), code `${this.emitter.emitTypeReference(elementType)}[]`);
         }
         arrayLiteral(array, elementType) {
-            return this.emitter.result.rawCode(code `${this.emitter.emitTypeReference(elementType)}[]`);
+            this.emitter.emitType(elementType, this.emitter.getContext());
+            const csType = getCSharpType(this.emitter.getProgram(), array, this.#getOrAddNamespaceForType(elementType));
+            if (csType?.type) {
+                return code `${csType.type.getTypeReference(this.emitter.getContext()?.scope)}`;
+            }
+            return code `${this.emitter.emitTypeReference(elementType, this.emitter.getContext())}[]`;
         }
         booleanLiteral(boolean) {
-            return this.emitter.result.rawCode(code `${boolean.value === true ? "true" : "false"}`);
+            return code `${boolean.value === true ? "true" : "false"}`;
         }
         unionLiteral(union) {
             const csType = coalesceUnionTypes(this.emitter.getProgram(), union);
@@ -82,10 +150,7 @@ export async function $onEmit(context) {
             const doc = getDoc(this.emitter.getProgram(), en);
             const attributes = getModelAttributes(program, en, enumName);
             this.#metadateMap.set(en, new CSharpType({ name: enumName, namespace: namespace }));
-            return this.emitter.result.declaration(enumName, code `${this.#generatedFileHeader}
-        
-        ${this.#emitUsings()}
-        
+            return this.emitter.result.declaration(enumName, code `
         namespace ${namespace}
         {
 
@@ -103,7 +168,7 @@ export async function $onEmit(context) {
             const enumName = ensureCSharpIdentifier(this.emitter.getProgram(), en, en.name);
             const enumFile = this.emitter.createSourceFile(`generated/models/${enumName}.cs`);
             enumFile.meta[this.#sourceTypeKey] = CSharpSourceType.Model;
-            const enumNamespace = `${this.#getOrSetBaseNamespace(en)}.Models`;
+            const enumNamespace = this.#getOrAddNamespace(en.namespace);
             return this.#createEnumContext(enumNamespace, enumFile, enumName);
         }
         enumMembers(en) {
@@ -133,9 +198,8 @@ export async function $onEmit(context) {
         intrinsic(intrinsic, name) {
             switch (intrinsic.name) {
                 case "unknown":
-                    return this.emitter.result.rawCode(code `System.Text.Json.Nodes.JsonNode`);
                 case "null":
-                    return this.emitter.result.rawCode(code `System.Text.Json.Nodes.JsonNode`);
+                    return this.emitter.result.rawCode(code `${UnknownType.getTypeReference(this.emitter.getContext().scope)}`);
                 case "ErrorType":
                 case "never":
                     reportDiagnostic(this.emitter.getProgram(), {
@@ -146,7 +210,7 @@ export async function $onEmit(context) {
                     return "";
                 case "void":
                     const type = getCSharpTypeForIntrinsic(this.emitter.getProgram(), intrinsic);
-                    return this.emitter.result.rawCode(`${type?.type.getTypeReference()}`);
+                    return this.emitter.result.rawCode(`${type?.type.getTypeReference(this.emitter.getContext().scope)}`);
             }
         }
         #emitUsings(file) {
@@ -165,8 +229,13 @@ export async function $onEmit(context) {
                 return "";
             }
             const isErrorType = isErrorModel(this.emitter.getProgram(), model);
+            if (model.baseModel && model.baseModel.namespace !== model.namespace) {
+                const resolvedNs = this.#getOrAddNamespaceForType(model.baseModel);
+                if (resolvedNs)
+                    checkOrAddNamespaceToScope(resolvedNs, this.emitter.getContext().scope);
+            }
             const baseModelRef = model.baseModel
-                ? code `: ${this.emitter.emitTypeReference(model.baseModel)}`
+                ? code `: ${this.emitter.emitTypeReference(model.baseModel, this.emitter.getContext())}`
                 : "";
             const baseClass = baseModelRef || (isErrorType ? ": HttpServiceException" : "");
             const namespace = this.emitter.getContext().namespace;
@@ -177,9 +246,7 @@ export async function $onEmit(context) {
                 ? this.getModelExceptionConstructor(this.emitter.getProgram(), model, name, className)
                 : "";
             this.#metadateMap.set(model, new CSharpType({ name: className, namespace: namespace }));
-            const decl = this.emitter.result.declaration(className, code `${this.#generatedFileHeader}
-
-      ${this.#emitUsings()}
+            const decl = this.emitter.result.declaration(className, code `
       namespace ${namespace} {
 
       ${doc ? `${formatComment(doc)}\n` : ""}${`${attributes.map((attribute) => attribute.getApplicationString(this.emitter.getContext().scope)).join("\n")}${attributes?.length > 0 ? "\n" : ""}`}public partial class ${className} ${baseClass} {
@@ -263,20 +330,20 @@ export async function $onEmit(context) {
         }
         modelDeclarationContext(model, name) {
             if (this.#isMultipartModel(model))
-                return {};
+                return this.emitter.getContext();
             const modelName = ensureCSharpIdentifier(this.emitter.getProgram(), model, name);
             const modelFile = this.emitter.createSourceFile(`generated/models/${modelName}.cs`);
             modelFile.meta[this.#sourceTypeKey] = CSharpSourceType.Model;
-            const modelNamespace = `${this.#getOrSetBaseNamespace(model)}.Models`;
+            const modelNamespace = this.#getOrAddNamespace(model.namespace);
             return this.#createModelContext(modelNamespace, modelFile, modelName);
         }
         modelInstantiationContext(model) {
             if (this.#isMultipartModel(model))
-                return {};
+                return this.emitter.getContext();
             const modelName = getModelInstantiationName(this.emitter.getProgram(), model, model.name);
             const sourceFile = this.emitter.createSourceFile(`generated/models/${modelName}.cs`);
             sourceFile.meta[this.#sourceTypeKey] = CSharpSourceType.Model;
-            const modelNamespace = `${this.#getOrSetBaseNamespace(model)}.Models`;
+            const modelNamespace = this.#getOrAddNamespace(model.namespace);
             const context = this.#createModelContext(modelNamespace, sourceFile, model.name);
             context.instantiationName = modelName;
             return context;
@@ -290,12 +357,33 @@ export async function $onEmit(context) {
             const program = this.emitter.getProgram();
             const recordType = getRecordType(program, model);
             if (recordType !== undefined) {
-                return code `Dictionary<string, ${this.emitter.emitTypeReference(recordType)}>`;
+                const valueType = this.#getSimpleType(recordType);
+                return code `Dictionary<string, ${valueType ? valueType?.getTypeReference() : this.emitter.emitTypeReference(recordType)}>`;
             }
             const context = this.emitter.getContext();
             const className = context.instantiationName ?? name;
             return this.modelDeclaration(model, className);
         }
+        #getSimpleType(type) {
+            switch (type.kind) {
+                case "Model":
+                    if (!isRecord(type))
+                        return undefined;
+                    return getCSharpType(this.emitter.getProgram(), type)?.type;
+                case "Boolean":
+                case "Intrinsic":
+                case "ModelProperty":
+                case "Number":
+                case "Scalar":
+                case "String":
+                case "StringTemplate":
+                case "StringTemplateSpan":
+                case "Tuple":
+                    return getCSharpType(this.emitter.getProgram(), type)?.type;
+                default:
+                    return undefined;
+            }
+        }
         #getMultipartParts(model) {
             const parts = [...model.properties.values()]
                 .flatMap((p) => getHttpPart(this.emitter.getProgram(), p.type)?.type)
@@ -357,20 +445,26 @@ export async function $onEmit(context) {
             let propertyName = ensureCSharpIdentifier(this.emitter.getProgram(), property, property.name);
             const { typeReference: typeName, defaultValue: typeDefault, nullableType: nullable, } = this.#findPropertyType(property);
             const doc = getDoc(this.emitter.getProgram(), property);
-            const attributes = getModelAttributes(this.emitter.getProgram(), property, propertyName);
+            const attributes = new Map(getModelAttributes(this.emitter.getProgram(), property, propertyName).map((a) => [
+                a.type.name,
+                a,
+            ]));
             const modelName = this.emitter.getContext()["name"];
             if (modelName === propertyName ||
                 (this.isDuplicateExceptionName(propertyName) &&
                     property.model &&
                     isErrorModel(this.emitter.getProgram(), property.model))) {
                 propertyName = `${propertyName}Prop`;
-                attributes.push(getEncodedNameAttribute(this.emitter.getProgram(), property, propertyName));
+                const attr = getEncodedNameAttribute(this.emitter.getProgram(), property, propertyName);
+                if (!attributes.has(attr.type.name))
+                    attributes.set(attr.type.name, attr);
             }
             const defaultValue = property.defaultValue
                 ? code `${JSON.stringify(serializeValueAsJson(this.emitter.getProgram(), property.defaultValue, property))}`
                 : typeDefault;
+            const attributeList = [...attributes.values()];
             return this.emitter.result
-                .rawCode(code `${doc ? `${formatComment(doc)}\n` : ""}${`${attributes.map((attribute) => attribute.getApplicationString(this.emitter.getContext().scope)).join("\n")}${attributes?.length > 0 ? "\n" : ""}`}public ${this.#isInheritedProperty(property) ? "new " : ""}${typeName}${isValueType(this.emitter.getProgram(), property.type) && (property.optional || nullable)
+                .rawCode(code `${doc ? `${formatComment(doc)}\n` : ""}${`${attributeList.map((attribute) => attribute.getApplicationString(this.emitter.getContext().scope)).join("\n")}${attributeList?.length > 0 ? "\n" : ""}`}public ${this.#isInheritedProperty(property) ? "new " : ""}${typeName}${isValueType(this.emitter.getProgram(), property.type) && (property.optional || nullable)
                 ? "?"
                 : ""} ${propertyName} { get; ${typeDefault ? "}" : "set; }"}${defaultValue ? ` = ${defaultValue};\n` : "\n"}
     `);
@@ -405,10 +499,7 @@ export async function $onEmit(context) {
             const doc = getDoc(this.emitter.getProgram(), iface);
             const attributes = getModelAttributes(this.emitter.getProgram(), iface, ifaceName);
             this.#metadateMap.set(iface, new CSharpType({ name: ifaceName, namespace: namespace }));
-            const decl = this.emitter.result.declaration(ifaceName, code `${this.#generatedFileHeaderWithNullable}
-
-      ${this.#emitUsings()}
-
+            const decl = this.emitter.result.declaration(ifaceName, code `
       namespace ${namespace} {
 
       ${doc ? `${formatComment(doc)}\n` : ""}${`${attributes.map((attribute) => attribute.getApplicationString(this.emitter.getContext().scope)).join("\n")}${attributes?.length > 0 ? "\n" : ""}`}public interface ${ifaceName} {
@@ -422,48 +513,44 @@ export async function $onEmit(context) {
             const ifaceName = `I${ensureCSharpIdentifier(this.emitter.getProgram(), iface, name, NameCasingType.Class)}`;
             const sourceFile = this.emitter.createSourceFile(`generated/operations/${ifaceName}.cs`);
             sourceFile.meta[this.#sourceTypeKey] = CSharpSourceType.Interface;
-            const ifaceNamespace = this.#getOrSetBaseNamespace(iface);
-            const modelNamespace = `${ifaceNamespace}.Models`;
-            const context = this.#createModelContext(ifaceNamespace, sourceFile, ifaceName);
-            context.file.imports.set("System", ["System"]);
-            context.file.imports.set("System.Net", ["System.Net"]);
-            context.file.imports.set("System.Text.Json", ["System.Text.Json"]);
-            context.file.imports.set("System.Text.Json.Serialization", [
-                "System.Text.Json.Serialization",
-            ]);
-            context.file.imports.set("System.Threading.Tasks", ["System.Threading.Tasks"]);
-            context.file.imports.set("Microsoft.AspNetCore.Mvc", ["Microsoft.AspNetCore.Mvc"]);
+            sourceFile.meta["nullable"] = true;
+            const ifaceNamespace = this.#getOrAddNamespace(iface.namespace);
+            sourceFile.imports.set("System", ["System"]);
+            sourceFile.imports.set("System.Net", ["System.Net"]);
+            sourceFile.imports.set("System.Text.Json", ["System.Text.Json"]);
+            sourceFile.imports.set("System.Text.Json.Serialization", ["System.Text.Json.Serialization"]);
+            sourceFile.imports.set("System.Threading.Tasks", ["System.Threading.Tasks"]);
+            sourceFile.imports.set("Microsoft.AspNetCore.Mvc", ["Microsoft.AspNetCore.Mvc"]);
             if (this.#hasMultipartOperation(iface)) {
-                context.file.imports.set("Microsoft.AspNetCore.WebUtilities", [
+                sourceFile.imports.set("Microsoft.AspNetCore.WebUtilities", [
                     "Microsoft.AspNetCore.WebUtilities",
                 ]);
             }
-            context.file.imports.set(modelNamespace, [modelNamespace]);
-            return context;
+            return this.#createModelContext(ifaceNamespace, sourceFile, ifaceName);
         }
         interfaceDeclarationOperations(iface) {
             // add in operations
             const builder = new StringBuilder();
-            const metadata = new HttpMetadata();
             const context = this.emitter.getContext();
             const name = `${ensureCSharpIdentifier(this.emitter.getProgram(), iface, iface.name, NameCasingType.Class)}`;
-            const ifaceNamespace = this.#getOrSetBaseNamespace(iface);
-            const namespace = `${ifaceNamespace}`;
+            const ifaceNamespace = this.#getOrAddNamespace(iface.namespace);
+            const namespace = ifaceNamespace;
             const mock = {
                 className: name,
                 interfaceName: `I${name}`,
                 methods: [],
                 namespace: namespace,
-                usings: [`${ifaceNamespace}.Models`],
+                usings: [],
             };
             for (const [name, operation] of iface.operations) {
                 const doc = getDoc(this.emitter.getProgram(), operation);
                 const returnTypes = [];
                 const [httpOp, _] = getHttpOperation(this.emitter.getProgram(), operation);
                 for (const response of httpOp.responses.filter((r) => !isErrorModel(this.emitter.getProgram(), r.type))) {
-                    returnTypes.push(metadata.resolveLogicalResponseType(this.emitter.getProgram(), response));
+                    const [_, responseType] = this.#resolveOperationResponse(response, httpOp.operation);
+                    returnTypes.push(responseType);
                 }
-                const returnInfo = coalesceTypes(this.emitter.getProgram(), returnTypes, context.namespace);
+                const returnInfo = coalesceTypes(this.emitter.getProgram(), returnTypes, namespace);
                 const returnType = returnInfo?.type || UnknownType;
                 const opName = ensureCSharpIdentifier(this.emitter.getProgram(), operation, name, NameCasingType.Method);
                 const parameters = this.#opHelpers.getParameters(this.emitter.getProgram(), httpOp);
@@ -481,6 +568,7 @@ export async function $onEmit(context) {
                 builder.push(code `${opDecl.value}\n`);
                 this.emitter.emitInterfaceOperation(operation);
             }
+            mock.usings.push(...getImports(context.scope));
             this.#mockRegistrations.set(mock.interfaceName, mock);
             return builder.reduce();
         }
@@ -605,6 +693,23 @@ export async function $onEmit(context) {
         stringTemplate(stringTemplate) {
             return this.emitter.result.rawCode(stringTemplate.stringValue || "");
         }
+        #resolveOperationResponse(response, operation) {
+            function getName(sourceType, part) {
+                return ensureCSharpIdentifier(emitter.getProgram(), sourceType, part, NameCasingType.Class);
+            }
+            let responseType = new HttpMetadata().resolveLogicalResponseType(this.emitter.getProgram(), response);
+            if (responseType.kind === "Model" && !responseType.name) {
+                const modelName = `${getName(responseType, operation.interface.name)}${getName(responseType, operation.name)}Response}`;
+                const returnedType = this.emitter
+                    .getProgram()
+                    .checker.cloneType(responseType, { name: modelName });
+                responseType = returnedType;
+            }
+            this.emitter.emitType(responseType);
+            const context = this.emitter.getContext();
+            const result = getCSharpType(this.emitter.getProgram(), responseType, context.namespace);
+            return [result?.type || UnknownType, responseType];
+        }
         #getOperationResponse(operation) {
             const validResponses = operation.responses.filter((r) => !isErrorModel(this.emitter.getProgram(), r.type) &&
                 getCSharpStatusCode(r.statusCodes) !== undefined);
@@ -625,46 +730,36 @@ export async function $onEmit(context) {
             };
         }
         #emitOperationResponses(operation) {
-            const builder = new StringBuilder();
-            let i = 0;
-            const validResponses = operation.responses.filter((r) => !isErrorModel(this.emitter.getProgram(), r.type) &&
-                getCSharpStatusCode(r.statusCodes) !== undefined);
-            for (const response of validResponses) {
-                i++;
-                builder.push(code `${this.#emitOperationResponseDecorator(response)}`);
-                if (i < validResponses.length) {
-                    builder.pushLiteralSegment("\n");
-                }
+            function isValid(program, response) {
+                return (!isErrorModel(program, response.type) &&
+                    getCSharpStatusCode(response.statusCodes) !== undefined);
             }
+            const builder = new StringBuilder();
             for (const response of operation.responses) {
-                if (!isEmptyResponseModel(this.emitter.getProgram(), response.type))
-                    this.emitter.emitType(response.type);
+                const [responseType, _] = this.#resolveOperationResponse(response, operation.operation);
+                if (isValid(this.emitter.getProgram(), response)) {
+                    builder.push(code `${builder.segments.length > 0 ? "\n" : ""}${this.#emitOperationResponseDecorator(response, responseType)}`);
+                }
             }
             return builder.reduce();
         }
-        #emitOperationResponseDecorator(response) {
-            const responseType = new HttpMetadata().resolveLogicalResponseType(this.emitter.getProgram(), response);
-            return this.emitter.result.rawCode(code `[ProducesResponseType((int)${getCSharpStatusCode(response.statusCodes)}, Type = typeof(${this.#emitResponseType(responseType)}))]`);
+        #emitOperationResponseDecorator(response, result) {
+            return this.emitter.result.rawCode(code `[ProducesResponseType((int)${getCSharpStatusCode(response.statusCodes)}, Type = typeof(${this.#emitResponseType(result)}))]`);
         }
         #emitResponseType(type) {
             const context = this.emitter.getContext();
-            const result = getCSharpType(this.emitter.getProgram(), type, context.namespace);
-            const resultType = result?.type || UnknownType;
-            return resultType.getTypeReference(context.scope);
+            return type.getTypeReference(context.scope);
         }
         unionDeclaration(union, name) {
             const baseType = coalesceUnionTypes(this.emitter.getProgram(), union);
-            if (baseType.isBuiltIn && baseType.name === "string") {
+            if (isStringEnumType(this.emitter.getProgram(), union)) {
                 const program = this.emitter.getProgram();
                 const unionName = ensureCSharpIdentifier(program, union, name);
                 const namespace = this.emitter.getContext().namespace;
                 const doc = getDoc(this.emitter.getProgram(), union);
                 const attributes = getModelAttributes(program, union, unionName);
                 this.#metadateMap.set(union, new CSharpType({ name: unionName, namespace: namespace }));
-                return this.emitter.result.declaration(unionName, code `${this.#generatedFileHeader}
-        
-        ${this.#emitUsings()}
-        
+                return this.emitter.result.declaration(unionName, code `
         namespace ${namespace}
         {
 
@@ -672,24 +767,19 @@ export async function $onEmit(context) {
             ${attributes.map((attribute) => attribute.getApplicationString(this.emitter.getContext().scope)).join("\n")}
             public enum ${unionName}
             {
-              ${this.emitter.emitUnionVariants(union)};
+              ${this.emitter.emitUnionVariants(union)}
             }
         } `);
             }
-            return this.emitter.result.rawCode(code `${baseType.getTypeReference()}`);
+            return this.emitter.result.rawCode(code `${baseType.getTypeReference(this.emitter.getContext().scope)}`);
         }
         unionDeclarationContext(union) {
-            const baseType = coalesceUnionTypes(this.emitter.getProgram(), union);
-            if (baseType.isBuiltIn && baseType.name === "string") {
+            if (isStringEnumType(this.emitter.getProgram(), union)) {
                 const unionName = ensureCSharpIdentifier(this.emitter.getProgram(), union, union.name || "Union");
                 const unionFile = this.emitter.createSourceFile(`generated/models/${unionName}.cs`);
                 unionFile.meta[this.#sourceTypeKey] = CSharpSourceType.Model;
-                const unionNamespace = `${this.#getOrSetBaseNamespace(union)}.Models`;
-                return {
-                    namespace: unionNamespace,
-                    file: unionFile,
-                    scope: unionFile.globalScope,
-                };
+                const unionNamespace = this.#getOrAddNamespace(union.namespace);
+                return this.#createEnumContext(unionNamespace, unionFile, unionName);
             }
             else {
                 return this.emitter.getContext();
@@ -710,7 +800,9 @@ export async function $onEmit(context) {
                     const nameHint = name || variant.type.value;
                     const memberName = ensureCSharpIdentifier(this.emitter.getProgram(), variant, nameHint);
                     this.#metadateMap.set(variant, { name: memberName });
-                    result.push(code `${ensureCSharpIdentifier(this.emitter.getProgram(), variant, nameHint)} = "${variant.type.value}"`);
+                    result.push(code `
+            [JsonStringEnumMemberName("${variant.type.value}")]
+            ${ensureCSharpIdentifier(this.emitter.getProgram(), variant, nameHint, NameCasingType.Property)}`);
                     if (i < union.variants.size)
                         result.pushLiteralSegment(", ");
                 }
@@ -721,66 +813,57 @@ export async function $onEmit(context) {
             return super.unionVariantContext(union);
         }
         #createModelContext(namespace, file, name) {
+            file.imports.set("System", ["System"]);
+            file.imports.set("System.Text.Json", ["System.Text.Json"]);
+            file.imports.set("System.Text.Json.Serialization", ["System.Text.Json.Serialization"]);
+            file.imports.set("TypeSpec.Helpers.JsonConverters", ["TypeSpec.Helpers.JsonConverters"]);
+            file.imports.set("TypeSpec.Helpers", ["TypeSpec.Helpers"]);
+            file.meta[this.#nsKey] = namespace;
             const context = {
                 namespace: namespace,
                 name: name,
                 file: file,
                 scope: file.globalScope,
             };
-            context.file.imports.set("System", ["System"]);
-            context.file.imports.set("System.Text.Json", ["System.Text.Json"]);
-            context.file.imports.set("System.Text.Json.Serialization", [
-                "System.Text.Json.Serialization",
-            ]);
-            context.file.imports.set("TypeSpec.Helpers.JsonConverters", [
-                "TypeSpec.Helpers.JsonConverters",
-            ]);
-            context.file.imports.set("TypeSpec.Helpers", ["TypeSpec.Helpers"]);
             return context;
         }
         #createEnumContext(namespace, file, name) {
-            const context = {
+            file.imports.set("System.Text.Json", ["System.Text.Json"]);
+            file.imports.set("System.Text.Json.Serialization", ["System.Text.Json.Serialization"]);
+            return {
                 namespace: namespace,
                 name: name,
                 file: file,
                 scope: file.globalScope,
             };
-            context.file.imports.set("System.Text.Json", ["System.Text.Json"]);
-            context.file.imports.set("System.Text.Json.Serialization", [
-                "System.Text.Json.Serialization",
-            ]);
-            return context;
         }
         #createOrGetResourceContext(name, operation, resource) {
             name = ensureCSharpIdentifier(this.emitter.getProgram(), operation, name, NameCasingType.Class);
-            let context = controllers.get(name);
+            const namespace = this.#getOrAddNamespace(operation.namespace);
+            let context = controllers.get(`${namespace}.${name}`);
             if (context !== undefined)
                 return context;
             const sourceFile = this.emitter.createSourceFile(`generated/controllers/${name}Controller.cs`);
-            const namespace = this.#getOrSetBaseNamespace(operation);
-            const modelNamespace = `${namespace}.Models`;
             sourceFile.meta[this.#sourceTypeKey] = CSharpSourceType.Controller;
             sourceFile.meta["resourceName"] = name;
             sourceFile.meta["resource"] = `${name}Controller`;
             sourceFile.meta["namespace"] = namespace;
+            sourceFile.imports.set("System", ["System"]);
+            sourceFile.imports.set("System.Net", ["System.Net"]);
+            sourceFile.imports.set("System.Threading.Tasks", ["System.Threading.Tasks"]);
+            sourceFile.imports.set("System.Text.Json", ["System.Text.Json"]);
+            sourceFile.imports.set("System.Text.Json.Serialization", ["System.Text.Json.Serialization"]);
+            sourceFile.imports.set("Microsoft.AspNetCore.Mvc", ["Microsoft.AspNetCore.Mvc"]);
+            sourceFile.imports.set(namespace, [namespace]);
+            sourceFile.meta[this.#nsKey] = namespace;
             context = {
-                namespace: sourceFile.meta["namespace"],
+                namespace: namespace,
                 file: sourceFile,
                 resourceName: name,
                 scope: sourceFile.globalScope,
                 resourceType: resource,
             };
-            context.file.imports.set("System", ["System"]);
-            context.file.imports.set("System.Net", ["System.Net"]);
-            context.file.imports.set("System.Threading.Tasks", ["System.Threading.Tasks"]);
-            context.file.imports.set("System.Text.Json", ["System.Text.Json"]);
-            context.file.imports.set("System.Text.Json.Serialization", [
-                "System.Text.Json.Serialization",
-            ]);
-            context.file.imports.set("Microsoft.AspNetCore.Mvc", ["Microsoft.AspNetCore.Mvc"]);
-            context.file.imports.set(modelNamespace, [modelNamespace]);
-            context.file.imports.set(namespace, [namespace]);
-            controllers.set(name, context);
+            controllers.set(`${namespace}.${name}`, context);
             return context;
         }
         // eslint-disable-next-line no-unused-private-class-members
@@ -821,9 +904,20 @@ export async function $onEmit(context) {
         }
         #emitCodeContents(file) {
             const contents = new StringBuilder();
+            contents.pushLiteralSegment(`${file.meta["nullable"] ? this.#generatedFileHeaderWithNullable : this.#generatedFileHeader}
+        
+        ${this.#emitUsings(file)}
+        `);
             for (const decl of file.globalScope.declarations) {
                 contents.push(decl.value);
             }
+            for (const child of file.globalScope.childScopes) {
+                if (child.declarations) {
+                    for (const decl of child.declarations) {
+                        contents.push(decl.value);
+                    }
+                }
+            }
             return contents.segments.join("\n") + "\n";
         }
         #emitControllerContents(file) {
@@ -932,19 +1026,6 @@ export async function $onEmit(context) {
             }
             return super.writeOutput(emittedSourceFiles);
         }
-        #getOrSetBaseNamespace(type) {
-            if (this.#baseNamespace === undefined) {
-                if (type.namespace !== undefined) {
-                    this.#baseNamespace = `${type.namespace
-                        ? ensureCSharpIdentifier(this.emitter.getProgram(), type.namespace, getNamespaceFullName(type.namespace))
-                        : "TypeSpec"}.Service`;
-                }
-                else {
-                    this.#baseNamespace = "TypeSpec.Service";
-                }
-            }
-            return this.#baseNamespace;
-        }
     }
     function processNameSpace(program, target, service) {
         if (!service)