@typespec/http-server-csharp 0.58.0-alpha.10-dev.0 → 0.58.0-alpha.10-dev.2

package/dist/src/lib/service.js

@@ -1,15 +1,16 @@
 import { getDoc, getNamespaceFullName, getService, isErrorModel, isNeverType, isNullType, isTemplateDeclaration, isVoidType, } from "@typespec/compiler";
 import { CodeTypeEmitter, StringBuilder, code, createAssetEmitter, } from "@typespec/compiler/emitter-framework";
 import { createRekeyableMap } from "@typespec/compiler/utils";
-import { Visibility, createMetadataInfo, getHeaderFieldName, getHttpOperation, getHttpPart, isHeader, isPathParam, isQueryParam, isStatusCode, } from "@typespec/http";
+import { getHttpOperation, getHttpPart, isStatusCode, } from "@typespec/http";
 import { getResourceOperation } from "@typespec/rest";
 import { execFile } from "child_process";
+import { getEncodedNameAttribute } from "./attributes.js";
 import { GeneratedFileHeader, GeneratedFileHeaderWithNullable, getSerializationSourceFiles, } from "./boilerplate.js";
 import { CSharpSourceType, CSharpType, NameCasingType, } from "./interfaces.js";
 import { reportDiagnostic } from "./lib.js";
-import { getBusinessLogicImplementations, getScaffoldingHelpers, } from "./scaffolding.js";
+import { getBusinessLogicImplementations, } from "./scaffolding.js";
 import { getRecordType, isKnownReferenceType } from "./type-helpers.js";
-import { HttpMetadata, UnknownType, coalesceTypes, ensureCSharpIdentifier, ensureCleanDirectory, formatComment, getCSharpIdentifier, getCSharpStatusCode, getCSharpType, getCSharpTypeForIntrinsic, getCSharpTypeForScalar, getModelAttributes, getModelInstantiationName, getOperationVerbDecorator, isValueType, } from "./utils.js";
+import { CSharpOperationHelpers, HttpMetadata, UnknownType, coalesceTypes, coalesceUnionTypes, ensureCSharpIdentifier, ensureCleanDirectory, formatComment, getBusinessLogicCallParameters, getBusinessLogicDeclParameters, getCSharpIdentifier, getCSharpStatusCode, getCSharpType, getCSharpTypeForIntrinsic, getCSharpTypeForScalar, getHttpDeclParameters, getModelAttributes, getModelDeclarationName, getModelInstantiationName, getOperationVerbDecorator, isEmptyResponseModel, isValueType, } from "./utils.js";
 export async function $onEmit(context) {
     let _unionCounter = 0;
     const controllers = new Map();
@@ -27,14 +28,8 @@ export async function $onEmit(context) {
         #useSwagger = context.options["use-swaggerui"] || false;
         #openapiPath = context.options["openapi-path"] || "openapi/openapi.yaml";
         #mockRegistrations = new Map();
-        #mockHelpers = this.#emitMocks === "all"
-            ? getScaffoldingHelpers(this.emitter, this.#useSwagger, this.#openapiPath)
-            : [];
         #mockFiles = [];
-        #metaInfo = createMetadataInfo(this.emitter.getProgram(), {
-            canonicalVisibility: Visibility.Read,
-            canShareProperty: (p) => true,
-        });
+        #opHelpers = new CSharpOperationHelpers(this.emitter);
         arrayDeclaration(array, name, elementType) {
             return this.emitter.result.declaration(ensureCSharpIdentifier(this.emitter.getProgram(), array, name), code `${this.emitter.emitTypeReference(elementType)}[]`);
         }
@@ -45,8 +40,8 @@ export async function $onEmit(context) {
             return this.emitter.result.rawCode(code `${boolean.value === true ? "true" : "false"}`);
         }
         unionLiteral(union) {
-            const csType = this.#coalesceUnionTypes(union);
-            return this.emitter.result.rawCode(csType && csType.isBuiltIn ? csType.name : "object");
+            const csType = coalesceUnionTypes(this.emitter.getProgram(), union);
+            return this.emitter.result.rawCode(csType ? csType.getTypeReference(this.emitter.getContext()?.scope) : "object");
         }
         declarationName(declarationType) {
             switch (declarationType.kind) {
@@ -60,7 +55,7 @@ export async function $onEmit(context) {
                     return getCSharpIdentifier(declarationType.name, NameCasingType.Class);
                 case "Model":
                     if (!declarationType.name)
-                        return `Model${_unionCounter++}`;
+                        return getModelDeclarationName(this.emitter.getProgram(), declarationType, `${_unionCounter++}`);
                     return getCSharpIdentifier(declarationType.name, NameCasingType.Class);
                 case "Operation":
                     return getCSharpIdentifier(declarationType.name, NameCasingType.Class);
@@ -91,7 +86,7 @@ export async function $onEmit(context) {
             ${attributes.map((attribute) => attribute.getApplicationString(this.emitter.getContext().scope)).join("\n")}
             public enum ${enumName}
             {
-              ${this.emitter.emitEnumMembers(en)};
+              ${this.emitter.emitEnumMembers(en)}
             }
         } `);
         }
@@ -100,11 +95,7 @@ export async function $onEmit(context) {
             const enumFile = this.emitter.createSourceFile(`models/${enumName}.cs`);
             enumFile.meta[this.#sourceTypeKey] = CSharpSourceType.Model;
             const enumNamespace = `${this.#getOrSetBaseNamespace(en)}.Models`;
-            return {
-                namespace: enumNamespace,
-                file: enumFile,
-                scope: enumFile.globalScope,
-            };
+            return this.#createEnumContext(enumNamespace, enumFile, enumName);
         }
         enumMembers(en) {
             const result = new StringBuilder();
@@ -113,9 +104,11 @@ export async function $onEmit(context) {
                 i++;
                 const memberName = ensureCSharpIdentifier(this.emitter.getProgram(), member, name);
                 this.#metadateMap.set(member, { name: memberName });
-                result.push(code `${ensureCSharpIdentifier(this.emitter.getProgram(), member, name)} = "${member.value ? member.value : name}"`);
+                result.push(code `
+          [JsonStringEnumMemberName("${member.value ? member.value : name}")]
+          ${ensureCSharpIdentifier(this.emitter.getProgram(), member, name)}`);
                 if (i < en.members.size)
-                    result.pushLiteralSegment(", ");
+                    result.pushLiteralSegment(",\n");
             }
             return this.emitter.result.rawCode(result.reduce());
         }
@@ -243,9 +236,6 @@ export async function $onEmit(context) {
             });
             return this.modelDeclaration(model, modelName);
         }
-        #isRecord(type) {
-            return type.kind === "Model" && type.name === "Record" && type.indexer !== undefined;
-        }
         #isInheritedProperty(property) {
             const visited = [];
             function isInherited(model, propertyName) {
@@ -266,10 +256,15 @@ export async function $onEmit(context) {
         modelPropertyLiteral(property) {
             if (isStatusCode(this.emitter.getProgram(), property))
                 return "";
-            const propertyName = ensureCSharpIdentifier(this.emitter.getProgram(), property, property.name);
-            const [typeName, typeDefault, nullable] = this.#findPropertyType(property);
+            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 modelName = this.emitter.getContext()["name"];
+            if (modelName === propertyName) {
+                propertyName = `${propertyName}Prop`;
+                attributes.push(getEncodedNameAttribute(this.emitter.getProgram(), property, propertyName));
+            }
             // eslint-disable-next-line @typescript-eslint/no-deprecated
             const defaultValue = property.default
                 ? // eslint-disable-next-line @typescript-eslint/no-deprecated
@@ -282,7 +277,7 @@ export async function $onEmit(context) {
     `);
         }
         #findPropertyType(property) {
-            return this.#getTypeInfoForTsType(property.type);
+            return this.#opHelpers.getTypeInfo(this.emitter.getProgram(), property.type);
         }
         #isMultipartRequest(operation) {
             const body = operation.parameters.body;
@@ -298,118 +293,6 @@ export async function $onEmit(context) {
             }
             return false;
         }
-        #getTypeInfoForUnion(union) {
-            const propResult = this.#getNonNullableTsType(union);
-            if (propResult === undefined) {
-                return [
-                    code `${emitter.emitTypeReference(union)}`,
-                    undefined,
-                    [...union.variants.values()].filter((v) => isNullType(v.type)).length > 0,
-                ];
-            }
-            const [typeName, typeDefault, _] = this.#getTypeInfoForTsType(propResult.type);
-            return [typeName, typeDefault, propResult.nullable];
-        }
-        #getTypeInfoForTsType(tsType) {
-            function extractStringValue(type, span) {
-                switch (type.kind) {
-                    case "String":
-                        return type.value;
-                    case "Boolean":
-                        return `${type.value}`;
-                    case "Number":
-                        return type.valueAsString;
-                    case "StringTemplateSpan":
-                        if (type.isInterpolated) {
-                            return extractStringValue(type.type, span);
-                        }
-                        else {
-                            return type.type.value;
-                        }
-                    case "ModelProperty":
-                        return extractStringValue(type.type, span);
-                    case "EnumMember":
-                        if (type.value === undefined)
-                            return type.name;
-                        if (typeof type.value === "string")
-                            return type.value;
-                        if (typeof type.value === "number")
-                            return `${type.value}`;
-                }
-                reportDiagnostic(emitter.getProgram(), {
-                    code: "invalid-interpolation",
-                    target: span,
-                    format: {},
-                });
-                return "";
-            }
-            switch (tsType.kind) {
-                case "String":
-                    return [code `string`, `"${tsType.value}"`, false];
-                case "StringTemplate":
-                    const template = tsType;
-                    if (template.stringValue !== undefined)
-                        return [code `string`, `"${template.stringValue}"`, false];
-                    const spanResults = [];
-                    for (const span of template.spans) {
-                        spanResults.push(extractStringValue(span, span));
-                    }
-                    return [code `string`, `"${spanResults.join("")}"`, false];
-                case "Boolean":
-                    return [code `bool`, `${tsType.value === true ? true : false}`, false];
-                case "Number":
-                    const [type, value] = this.#findNumericType(tsType);
-                    return [code `${type}`, `${value}`, false];
-                case "Tuple":
-                    const defaults = [];
-                    const [csharpType, isObject] = this.#coalesceTypes(tsType.values);
-                    if (isObject)
-                        return ["object[]", undefined, false];
-                    for (const value of tsType.values) {
-                        const [_, itemDefault] = this.#getTypeInfoForTsType(value);
-                        defaults.push(itemDefault);
-                    }
-                    return [
-                        code `${csharpType.getTypeReference()}[]`,
-                        `[${defaults.join(", ")}]`,
-                        csharpType.isNullable,
-                    ];
-                case "Object":
-                    return [code `object`, undefined, false];
-                case "Model":
-                    if (this.#isRecord(tsType)) {
-                        return [code `JsonObject`, undefined, false];
-                    }
-                    return [code `${emitter.emitTypeReference(tsType)}`, undefined, false];
-                case "ModelProperty":
-                    return this.#getTypeInfoForTsType(tsType.type);
-                case "Enum":
-                    return [code `${emitter.emitTypeReference(tsType)}`, undefined, false];
-                case "EnumMember":
-                    if (typeof tsType.value === "number") {
-                        const stringValue = tsType.value.toString();
-                        if (stringValue.includes(".") || stringValue.includes("e"))
-                            return ["double", stringValue, false];
-                        return ["int", stringValue, false];
-                    }
-                    if (typeof tsType.value === "string") {
-                        return ["string", tsType.value, false];
-                    }
-                    return [code `object`, undefined, false];
-                case "Union":
-                    return this.#getTypeInfoForUnion(tsType);
-                case "UnionVariant":
-                    return this.#getTypeInfoForTsType(tsType.type);
-                default:
-                    return [code `${emitter.emitTypeReference(tsType)}`, undefined, false];
-            }
-        }
-        #findNumericType(type) {
-            const stringValue = type.valueAsString;
-            if (stringValue.includes(".") || stringValue.includes("e"))
-                return ["double", stringValue];
-            return ["int", stringValue];
-        }
         modelPropertyReference(property) {
             return code `${this.emitter.emitTypeReference(property.type)}`;
         }
@@ -484,30 +367,17 @@ export async function $onEmit(context) {
                 const returnInfo = coalesceTypes(this.emitter.getProgram(), returnTypes, context.namespace);
                 const returnType = returnInfo?.type || UnknownType;
                 const opName = ensureCSharpIdentifier(this.emitter.getProgram(), operation, name, NameCasingType.Method);
-                let opDecl;
-                let opImpl;
-                if (this.#isMultipartRequest(httpOp)) {
-                    opImpl = {
-                        methodName: `${opName}Async`,
-                        methodParams: `${this.#emitInterfaceOperationParameters(operation, "MultipartReader reader")}`,
-                        returnType: `${returnType.name === "void" ? "Task" : `Task<${returnType.getTypeReference(context.scope)}>`}`,
-                        instantiatedReturnType: returnType.name === "void"
-                            ? undefined
-                            : `${returnType.getTypeReference(context.scope)}`,
-                    };
-                    opDecl = this.emitter.result.declaration(opName, code `${doc ? `${formatComment(doc)}\n` : ""}${opImpl.returnType} ${opImpl.methodName}( ${opImpl.methodParams});`);
-                }
-                else {
-                    opImpl = {
-                        methodName: `${opName}Async`,
-                        methodParams: `${this.#emitInterfaceOperationParameters(operation)}`,
-                        returnType: `${returnType.name === "void" ? "Task" : `Task<${returnType.getTypeReference(context.scope)}>`}`,
-                        instantiatedReturnType: returnType.name === "void"
-                            ? undefined
-                            : `${returnType.getTypeReference(context.scope)}`,
-                    };
-                    opDecl = this.emitter.result.declaration(opName, code `${doc ? `${formatComment(doc)}\n` : ""}${opImpl.returnType} ${opImpl.methodName}( ${opImpl.methodParams});`);
-                }
+                const parameters = this.#opHelpers.getParameters(this.emitter.getProgram(), httpOp);
+                const opImpl = {
+                    methodName: `${opName}Async`,
+                    methodParams: `${getBusinessLogicDeclParameters(parameters)}`,
+                    returnType: returnType,
+                    returnTypeName: `${returnType.name === "void" ? "Task" : `Task<${returnType.getTypeReference(context.scope)}>`}`,
+                    instantiatedReturnType: returnType.name === "void"
+                        ? undefined
+                        : `${returnType.getTypeReference(context.scope)}`,
+                };
+                const opDecl = this.emitter.result.declaration(opName, code `${doc ? `${formatComment(doc)}\n` : ""}${opImpl.returnTypeName} ${opImpl.methodName}( ${opImpl.methodParams});`);
                 mock.methods.push(opImpl);
                 builder.push(code `${opDecl.value}\n`);
                 this.emitter.emitInterfaceOperation(operation);
@@ -529,9 +399,8 @@ export async function $onEmit(context) {
             const doc = getDoc(this.emitter.getProgram(), operation);
             const [httpOperation, _] = getHttpOperation(this.emitter.getProgram(), operation);
             const multipart = this.#isMultipartRequest(httpOperation);
-            const declParams = !multipart
-                ? this.#emitHttpOperationParameters(httpOperation)
-                : this.#emitHttpOperationParameters(httpOperation, true);
+            const parameters = this.#opHelpers.getParameters(this.emitter.getProgram(), httpOperation);
+            const declParams = getHttpDeclParameters(parameters);
             if (multipart) {
                 const context = this.emitter.getContext();
                 context.file.imports.set("Microsoft.AspNetCore.WebUtilities", [
@@ -561,9 +430,9 @@ export async function $onEmit(context) {
         public virtual async Task<IActionResult> ${operationName}(${declParams})
         {
           ${hasResponseValue
-                    ? `var result = await ${this.emitter.getContext().resourceName}Impl.${operationName}Async(${this.#emitOperationCallParameters(httpOperation)});
+                    ? `var result = await ${this.emitter.getContext().resourceName}Impl.${operationName}Async(${getBusinessLogicCallParameters(parameters)});
           return ${resultString}(result);`
-                    : `await ${this.emitter.getContext().resourceName}Impl.${operationName}Async(${this.#emitOperationCallParameters(httpOperation)});
+                    : `await ${this.emitter.getContext().resourceName}Impl.${operationName}Async(${getBusinessLogicCallParameters(parameters)});
           return ${resultString}();`}
         }`);
             }
@@ -585,9 +454,9 @@ export async function $onEmit(context) {
 
           var reader = new MultipartReader(boundary, Request.Body);
           ${hasResponseValue
-                    ? `var result = await ${this.emitter.getContext().resourceName}Impl.${operationName}Async(${this.#emitOperationCallParameters(httpOperation, "reader")});
+                    ? `var result = await ${this.emitter.getContext().resourceName}Impl.${operationName}Async(${getBusinessLogicCallParameters(parameters)});
           return ${resultString}(result);`
-                    : `await ${this.emitter.getContext().resourceName}Impl.${operationName}Async(${this.#emitOperationCallParameters(httpOperation, "reader")});
+                    : `await ${this.emitter.getContext().resourceName}Impl.${operationName}Async(${getBusinessLogicCallParameters(parameters)});
           return ${resultString}();`}
         }`);
             }
@@ -603,7 +472,8 @@ export async function $onEmit(context) {
             const operationName = ensureCSharpIdentifier(this.emitter.getProgram(), operation, name, NameCasingType.Method);
             const doc = getDoc(this.emitter.getProgram(), operation);
             const [httpOperation, _] = getHttpOperation(this.emitter.getProgram(), operation);
-            const declParams = this.#emitHttpOperationParameters(httpOperation);
+            const parameters = this.#opHelpers.getParameters(this.emitter.getProgram(), httpOperation);
+            const declParams = getHttpDeclParameters(parameters);
             const responseInfo = this.#getOperationResponse(httpOperation);
             const status = responseInfo?.statusCode ?? 200;
             const response = responseInfo?.resultType ??
@@ -623,9 +493,9 @@ export async function $onEmit(context) {
         public virtual async Task<IActionResult> ${operationName}(${declParams})
         {
           ${hasResponseValue
-                ? `var result = await ${this.emitter.getContext().resourceName}Impl.${operationName}Async(${this.#emitOperationCallParameters(httpOperation)});
+                ? `var result = await ${this.emitter.getContext().resourceName}Impl.${operationName}Async(${getBusinessLogicCallParameters(parameters)});
           return ${resultString}(result);`
-                : `await ${this.emitter.getContext().resourceName}Impl.${operationName}Async(${this.#emitOperationCallParameters(httpOperation)});
+                : `await ${this.emitter.getContext().resourceName}Impl.${operationName}Async(${getBusinessLogicCallParameters(parameters)});
           return ${resultString}();`}
         }`);
         }
@@ -683,68 +553,8 @@ export async function $onEmit(context) {
             const resultType = result?.type || UnknownType;
             return resultType.getTypeReference(context.scope);
         }
-        #emitInterfaceOperationParameters(operation, bodyParam) {
-            const signature = new StringBuilder();
-            const requiredParams = [];
-            const optionalParams = [];
-            let totalParams = 0;
-            if (bodyParam !== undefined)
-                totalParams++;
-            const validParams = [...operation.parameters.properties.entries()].filter(([_, p]) => isValidParameter(this.emitter.getProgram(), p));
-            for (const [_, parameter] of validParams) {
-                if (!isContentTypeHeader(this.emitter.getProgram(), parameter) &&
-                    (bodyParam === undefined || isHttpMetadata(this.emitter.getProgram(), parameter))) {
-                    if (parameter.optional || parameter.defaultValue)
-                        optionalParams.push(parameter);
-                    else
-                        requiredParams.push(parameter);
-                    totalParams++;
-                }
-            }
-            let i = 1;
-            for (const requiredParam of requiredParams) {
-                const [paramType, _, __] = this.#findPropertyType(requiredParam);
-                signature.push(code `${paramType} ${ensureCSharpIdentifier(this.emitter.getProgram(), requiredParam, requiredParam.name, NameCasingType.Parameter)}${i++ < totalParams ? ", " : ""}`);
-            }
-            if (bodyParam) {
-                signature.push(bodyParam);
-                if (i++ < totalParams)
-                    signature.push(", ");
-            }
-            for (const optionalParam of optionalParams) {
-                const [paramType, _, __] = this.#findPropertyType(optionalParam);
-                signature.push(code `${paramType}? ${ensureCSharpIdentifier(this.emitter.getProgram(), optionalParam, optionalParam.name, NameCasingType.Parameter)}${i++ < totalParams ? ", " : ""}`);
-            }
-            return signature.reduce();
-        }
-        #emitHttpOperationParameters(operation, bodyParameter) {
-            const signature = new StringBuilder();
-            const bodyParam = operation.parameters.body;
-            let i = 0;
-            //const pathParameters = operation.parameters.parameters.filter((p) => p.type === "path");
-            const validParams = operation.parameters.parameters.filter((p) => isValidParameter(this.emitter.getProgram(), p.param));
-            const requiredParams = validParams.filter((p) => p.type === "path" || (!p.param.optional && p.param.defaultValue === undefined));
-            const optionalParams = validParams.filter((p) => p.type !== "path" && (p.param.optional || p.param.defaultValue !== undefined));
-            for (const parameter of requiredParams) {
-                signature.push(code `${this.#emitOperationSignatureParameter(operation, parameter)}${++i < requiredParams.length ? ", " : ""}`);
-            }
-            if (requiredParams.length > 0 &&
-                (optionalParams.length > 0 || (bodyParameter === undefined && bodyParam !== undefined))) {
-                signature.push(code `, `);
-            }
-            if (bodyParameter === undefined) {
-                if (bodyParam !== undefined) {
-                    signature.push(code `${this.emitter.emitTypeReference(this.#metaInfo.getEffectivePayloadType(bodyParam.type, Visibility.Create || Visibility.Update))} body${requiredParams.length > 0 && optionalParams.length > 0 ? ", " : ""}`);
-                }
-            }
-            i = 0;
-            for (const parameter of optionalParams) {
-                signature.push(code `${this.#emitOperationSignatureParameter(operation, parameter)}${++i < optionalParams.length ? ", " : ""}`);
-            }
-            return signature.reduce();
-        }
         unionDeclaration(union, name) {
-            const baseType = this.#coalesceUnionTypes(union);
+            const baseType = coalesceUnionTypes(this.emitter.getProgram(), union);
             if (baseType.isBuiltIn && baseType.name === "string") {
                 const program = this.emitter.getProgram();
                 const unionName = ensureCSharpIdentifier(program, union, name);
@@ -770,7 +580,7 @@ export async function $onEmit(context) {
             return this.emitter.result.rawCode(code `${baseType.getTypeReference()}`);
         }
         unionDeclarationContext(union) {
-            const baseType = this.#coalesceUnionTypes(union);
+            const baseType = coalesceUnionTypes(this.emitter.getProgram(), union);
             if (baseType.isBuiltIn && baseType.name === "string") {
                 const unionName = ensureCSharpIdentifier(this.emitter.getProgram(), union, union.name || "Union");
                 const unionFile = this.emitter.createSourceFile(`models/${unionName}.cs`);
@@ -811,89 +621,6 @@ export async function $onEmit(context) {
         unionVariantContext(union) {
             return super.unionVariantContext(union);
         }
-        #emitOperationSignatureParameter(operation, httpParam) {
-            const name = httpParam.param.name;
-            const parameter = httpParam.param;
-            const emittedName = ensureCSharpIdentifier(this.emitter.getProgram(), parameter, name, NameCasingType.Parameter);
-            let [emittedType, emittedDefault, _] = this.#findPropertyType(parameter);
-            if (emittedType.toString().endsWith("[]"))
-                emittedDefault = undefined;
-            // eslint-disable-next-line @typescript-eslint/no-deprecated
-            const defaultValue = parameter.default
-                ? // eslint-disable-next-line @typescript-eslint/no-deprecated
-                    code `${this.emitter.emitType(parameter.default)}`
-                : emittedDefault;
-            return this.emitter.result.rawCode(code `${httpParam.type !== "path" ? this.#emitParameterAttribute(httpParam) : ""}${emittedType} ${emittedName}${defaultValue === undefined ? "" : ` = ${defaultValue}`}`);
-        }
-        #getBodyParameters(operation) {
-            const bodyParam = operation.parameters.body;
-            if (bodyParam === undefined)
-                return undefined;
-            if (bodyParam.property !== undefined)
-                return [bodyParam.property];
-            if (bodyParam.type.kind !== "Model" || bodyParam.type.properties.size < 1)
-                return undefined;
-            return [...bodyParam.type.properties.values()];
-        }
-        #emitOperationCallParameters(operation, bodyParameter = "body") {
-            const signature = new StringBuilder();
-            let i = 0;
-            const bodyParameters = this.#getBodyParameters(operation);
-            //const pathParameters = operation.parameters.parameters.filter((p) => p.type === "path");
-            const valid = operation.parameters.parameters.filter((p) => isValidParameter(this.emitter.getProgram(), p.param));
-            const required = valid.filter((p) => p.type === "path" || (!p.param.optional && p.param.defaultValue === undefined));
-            const optional = valid.filter((p) => p.type !== "path" && (p.param.optional || p.param.defaultValue !== undefined));
-            for (const parameter of required) {
-                const contentType = isContentTypeHeader(this.emitter.getProgram(), parameter.param);
-                i++;
-                if (!isNeverType(parameter.param.type) &&
-                    !isNullType(parameter.param.type) &&
-                    !isVoidType(parameter.param.type) &&
-                    !contentType) {
-                    signature.push(code `${this.#emitOperationCallParameter(operation, parameter)}${i < valid.length || bodyParameters !== undefined ? ", " : ""}`);
-                }
-            }
-            if (bodyParameters !== undefined) {
-                if (bodyParameters.length === 1) {
-                    signature.push(code `${bodyParameter}`);
-                }
-                else {
-                    let j = 0;
-                    for (const parameter of bodyParameters) {
-                        j++;
-                        const propertyName = ensureCSharpIdentifier(this.emitter.getProgram(), parameter, parameter.name, NameCasingType.Property);
-                        signature.push(code `${bodyParameter}?.${propertyName}${j < bodyParameters.length || i < valid.length ? ", " : ""}`);
-                    }
-                }
-            }
-            for (const parameter of optional) {
-                const contentType = isContentTypeHeader(this.emitter.getProgram(), parameter.param);
-                i++;
-                if (!isNeverType(parameter.param.type) &&
-                    !isNullType(parameter.param.type) &&
-                    !isVoidType(parameter.param.type) &&
-                    !contentType) {
-                    signature.push(code `${this.#emitOperationCallParameter(operation, parameter)}${i < valid.length ? ", " : ""}`);
-                }
-            }
-            return signature.reduce();
-        }
-        #emitOperationCallParameter(operation, httpParam) {
-            const name = httpParam.param.name;
-            const parameter = httpParam.param;
-            const emittedName = ensureCSharpIdentifier(this.emitter.getProgram(), parameter, name, NameCasingType.Parameter);
-            return this.emitter.result.rawCode(code `${emittedName}`);
-        }
-        #emitParameterAttribute(parameter) {
-            switch (parameter.type) {
-                case "header":
-                    return code `[FromHeader(Name="${parameter.name}")] `;
-                case "query":
-                    return code `[FromQuery(Name="${parameter.name}")] `;
-                default:
-                    return "";
-            }
-        }
         #createModelContext(namespace, file, name) {
             const context = {
                 namespace: namespace,
@@ -906,9 +633,26 @@ export async function $onEmit(context) {
             context.file.imports.set("System.Text.Json.Serialization", [
                 "System.Text.Json.Serialization",
             ]);
+            context.file.imports.set("TypeSpec.Helpers.JsonConverters", [
+                "TypeSpec.Helpers.JsonConverters",
+            ]);
+            return context;
+        }
+        #createEnumContext(namespace, file, name) {
+            const context = {
+                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);
             if (context !== undefined)
                 return context;
@@ -962,12 +706,6 @@ export async function $onEmit(context) {
                 if (sourceFile === libFile.source)
                     return libFile.emitted;
             }
-            if (this.#emitMocks === "all") {
-                for (const helper of this.#mockHelpers) {
-                    if (sourceFile === helper.source)
-                        return helper.emitted;
-                }
-            }
             if (this.#mockFiles.length > 0) {
                 for (const mock of this.#mockFiles) {
                     if (sourceFile === mock.source)
@@ -998,7 +736,7 @@ export async function $onEmit(context) {
         #emitControllerContents(file) {
             const namespace = file.meta.namespace;
             const contents = new StringBuilder();
-            contents.push(`${this.#generatedFileHeader}\n\n`);
+            contents.push(`${this.#generatedFileHeaderWithNullable}\n\n`);
             contents.push(code `${this.#emitUsings(file)}\n`);
             contents.push("\n");
             contents.push(`namespace ${namespace}.Controllers\n`);
@@ -1063,88 +801,13 @@ export async function $onEmit(context) {
                 return params.reduce();
             return "";
         }
-        #coalesceUnionTypes(union) {
-            const [result, _] = this.#coalesceTypes([...union.variants.values()].flatMap((v) => v.type));
-            return result;
-        }
-        #getNonNullableTsType(union) {
-            const types = [...union.variants.values()];
-            const nulls = types.flatMap((v) => v.type).filter((t) => isNullType(t));
-            const nonNulls = types.flatMap((v) => v.type).filter((t) => !isNullType(t));
-            if (nonNulls.length === 1)
-                return { type: nonNulls[0], nullable: nulls.length > 0 };
-            return undefined;
-        }
-        #coalesceTypes(types) {
-            const defaultValue = [
-                new CSharpType({
-                    name: "object",
-                    namespace: "System",
-                    isValueType: false,
-                }),
-                true,
-            ];
-            let current = undefined;
-            let nullable = false;
-            for (const type of types) {
-                let candidate = undefined;
-                switch (type.kind) {
-                    case "Boolean":
-                        candidate = new CSharpType({ name: "bool", namespace: "System", isValueType: true });
-                        break;
-                    case "StringTemplate":
-                    case "String":
-                        candidate = new CSharpType({ name: "string", namespace: "System", isValueType: false });
-                        break;
-                    case "Number":
-                        const stringValue = type.valueAsString;
-                        if (stringValue.includes(".") || stringValue.includes("e")) {
-                            candidate = new CSharpType({
-                                name: "double",
-                                namespace: "System",
-                                isValueType: true,
-                            });
-                        }
-                        else {
-                            candidate = new CSharpType({ name: "int", namespace: "System", isValueType: true });
-                        }
-                        break;
-                    case "Union":
-                        candidate = this.#coalesceUnionTypes(type);
-                        break;
-                    case "Scalar":
-                        candidate = getCSharpTypeForScalar(this.emitter.getProgram(), type);
-                        break;
-                    case "Intrinsic":
-                        if (isNullType(type)) {
-                            nullable = true;
-                            candidate = current;
-                        }
-                        else {
-                            return defaultValue;
-                        }
-                        break;
-                    default:
-                        return defaultValue;
-                }
-                current = current ?? candidate;
-                if (current === undefined || (candidate !== undefined && !candidate.equals(current)))
-                    return defaultValue;
-            }
-            if (current !== undefined && nullable)
-                current.isNullable = true;
-            return current === undefined ? defaultValue : [current, false];
-        }
         writeOutput(sourceFiles) {
             for (const source of this.#libraryFiles) {
                 sourceFiles.push(source.source);
             }
             if (this.#emitMocks === "all") {
-                for (const helper of this.#mockHelpers) {
-                    sourceFiles.push(helper.source);
-                }
                 if (this.#mockRegistrations.size > 0) {
-                    const mocks = getBusinessLogicImplementations(this.emitter, this.#mockRegistrations);
+                    const mocks = getBusinessLogicImplementations(this.emitter, this.#mockRegistrations, this.#useSwagger, this.#openapiPath);
                     this.#mockFiles.push(...mocks);
                     sourceFiles.push(...mocks.flatMap((l) => l.source));
                 }
@@ -1185,26 +848,6 @@ export async function $onEmit(context) {
             return this.#baseNamespace;
         }
     }
-    function isEmptyResponseModel(program, model) {
-        if (model.kind !== "Model")
-            return false;
-        return model.properties.size === 1 && isStatusCode(program, [...model.properties.values()][0]);
-    }
-    function isContentTypeHeader(program, parameter) {
-        return (isHeader(program, parameter) &&
-            (parameter.name === "contentType" ||
-                getHeaderFieldName(program, parameter) === "Content-type"));
-    }
-    function isValidParameter(program, parameter) {
-        return (!isContentTypeHeader(program, parameter) &&
-            (parameter.type.kind !== "Intrinsic" || parameter.type.name !== "never"));
-    }
-    /** Determine whether the given parameter is http metadata */
-    function isHttpMetadata(program, property) {
-        return (isPathParam(program, property) ||
-            isHeader(program, property) ||
-            isQueryParam(program, property));
-    }
     function processNameSpace(program, target, service) {
         if (!service)
             service = getService(program, target);