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

package/dist/src/{service.js → lib/service.js}

@@ -1,29 +1,35 @@
-import { getDoc, getNamespaceFullName, getService, isErrorModel, isNeverType, isNullType, isVoidType, } from "@typespec/compiler";
-import { CodeTypeEmitter, Placeholder, StringBuilder, code, createAssetEmitter, } from "@typespec/compiler/emitter-framework";
-import { Visibility, createMetadataInfo, getHttpOperation, isStatusCode, } from "@typespec/http";
+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 { getHttpOperation, getHttpPart, isStatusCode, } from "@typespec/http";
 import { getResourceOperation } from "@typespec/rest";
 import { execFile } from "child_process";
-import { getSerializationSourceFiles } from "./boilerplate.js";
+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, } from "./scaffolding.js";
 import { getRecordType, isKnownReferenceType } from "./type-helpers.js";
-import { HttpMetadata, UnknownType, coalesceTypes, ensureCSharpIdentifier, ensureCleanDirectory, formatComment, getCSharpIdentifier, getCSharpStatusCode, getCSharpType, 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();
     const NoResourceContext = "RPCOperations";
+    const doNotEmit = context.program.compilerOptions.noEmit || false;
     class CSharpCodeEmitter extends CodeTypeEmitter {
         #metadateMap = new Map();
-        #licenseHeader = `// Copyright (c) Microsoft Corporation. All rights reserved.
-    // Licensed under the MIT License.`;
+        #generatedFileHeaderWithNullable = GeneratedFileHeaderWithNullable;
+        #generatedFileHeader = GeneratedFileHeader;
         #sourceTypeKey = "sourceType";
         #libraryFiles = getSerializationSourceFiles(this.emitter);
         #baseNamespace = undefined;
         #emitterOutputType = context.options["output-type"];
-        #metaInfo = createMetadataInfo(this.emitter.getProgram(), {
-            canonicalVisibility: Visibility.Read,
-            canShareProperty: (p) => true,
-        });
+        #emitMocks = context.options["emit-mocks"];
+        #useSwagger = context.options["use-swaggerui"] || false;
+        #openapiPath = context.options["openapi-path"] || "openapi/openapi.yaml";
+        #mockRegistrations = new Map();
+        #mockFiles = [];
+        #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)}[]`);
         }
@@ -34,14 +40,23 @@ export async function $onEmit(context) {
             return this.emitter.result.rawCode(code `${boolean.value === true ? "true" : "false"}`);
         }
         unionLiteral(union) {
-            const csType = this.#coalesceUnionTypes(union);
+            const csType = coalesceUnionTypes(this.emitter.getProgram(), union);
             return this.emitter.result.rawCode(csType && csType.isBuiltIn ? csType.name : "object");
         }
         declarationName(declarationType) {
             switch (declarationType.kind) {
                 case "Enum":
+                    if (!declarationType.name)
+                        return `Enum${_unionCounter++}`;
+                    return getCSharpIdentifier(declarationType.name, NameCasingType.Class);
                 case "Interface":
+                    if (!declarationType.name)
+                        return `Interface${_unionCounter++}`;
+                    return getCSharpIdentifier(declarationType.name, NameCasingType.Class);
                 case "Model":
+                    if (!declarationType.name)
+                        return getModelDeclarationName(this.emitter.getProgram(), declarationType, `${_unionCounter++}`);
+                    return getCSharpIdentifier(declarationType.name, NameCasingType.Class);
                 case "Operation":
                     return getCSharpIdentifier(declarationType.name, NameCasingType.Class);
                 case "Union":
@@ -60,8 +75,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.#licenseHeader}
-        // <auto-generated />
+            return this.emitter.result.declaration(enumName, code `${this.#generatedFileHeader}
         
         ${this.#emitUsings()}
         
@@ -72,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)}
             }
         } `);
         }
@@ -81,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();
@@ -94,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());
         }
@@ -108,13 +120,15 @@ export async function $onEmit(context) {
                     return this.emitter.result.rawCode(code `System.Text.Json.Nodes.JsonNode`);
                 case "ErrorType":
                 case "never":
-                case "void":
                     reportDiagnostic(this.emitter.getProgram(), {
                         code: "invalid-intrinsic",
                         target: intrinsic,
                         format: { typeName: intrinsic.name },
                     });
                     return "";
+                case "void":
+                    const type = getCSharpTypeForIntrinsic(this.emitter.getProgram(), intrinsic);
+                    return this.emitter.result.rawCode(`${type?.type.getTypeReference()}`);
             }
         }
         #emitUsings(file) {
@@ -127,13 +141,17 @@ export async function $onEmit(context) {
             return builder.segments.join("\n");
         }
         modelDeclaration(model, name) {
+            const parts = this.#getMultipartParts(model);
+            if (parts.length > 0) {
+                parts.forEach((p) => this.emitter.emitType(p));
+                return "";
+            }
             const className = ensureCSharpIdentifier(this.emitter.getProgram(), model, name);
             const namespace = this.emitter.getContext().namespace;
             const doc = getDoc(this.emitter.getProgram(), model);
             const attributes = getModelAttributes(this.emitter.getProgram(), model, className);
             this.#metadateMap.set(model, new CSharpType({ name: className, namespace: namespace }));
-            const decl = this.emitter.result.declaration(className, code `${this.#licenseHeader}
-      // <auto-generated />
+            const decl = this.emitter.result.declaration(className, code `${this.#generatedFileHeader}
 
       ${this.#emitUsings()}
       
@@ -146,22 +164,31 @@ export async function $onEmit(context) {
             return decl;
         }
         modelDeclarationContext(model, name) {
+            if (this.#isMultipartModel(model))
+                return {};
             const modelName = ensureCSharpIdentifier(this.emitter.getProgram(), model, name);
             const modelFile = this.emitter.createSourceFile(`models/${modelName}.cs`);
             modelFile.meta[this.#sourceTypeKey] = CSharpSourceType.Model;
             const modelNamespace = `${this.#getOrSetBaseNamespace(model)}.Models`;
-            return this.#createModelContext(modelNamespace, modelFile);
+            return this.#createModelContext(modelNamespace, modelFile, modelName);
         }
         modelInstantiationContext(model) {
+            if (this.#isMultipartModel(model))
+                return {};
             const modelName = getModelInstantiationName(this.emitter.getProgram(), model, model.name);
             const sourceFile = this.emitter.createSourceFile(`models/${modelName}.cs`);
             sourceFile.meta[this.#sourceTypeKey] = CSharpSourceType.Model;
             const modelNamespace = `${this.#getOrSetBaseNamespace(model)}.Models`;
-            const context = this.#createModelContext(modelNamespace, sourceFile);
+            const context = this.#createModelContext(modelNamespace, sourceFile, model.name);
             context.instantiationName = modelName;
             return context;
         }
         modelInstantiation(model, name) {
+            const parts = this.#getMultipartParts(model);
+            if (parts.length > 0) {
+                parts.forEach((p) => this.emitter.emitType(p));
+                return "";
+            }
             const program = this.emitter.getProgram();
             const recordType = getRecordType(program, model);
             if (recordType !== undefined) {
@@ -171,53 +198,100 @@ export async function $onEmit(context) {
             const className = context.instantiationName ?? name;
             return this.modelDeclaration(model, className);
         }
+        #getMultipartParts(model) {
+            const parts = [...model.properties.values()]
+                .flatMap((p) => getHttpPart(this.emitter.getProgram(), p.type)?.type)
+                .filter((t) => t !== undefined);
+            if (model.baseModel) {
+                return parts.concat(this.#getMultipartParts(model.baseModel));
+            }
+            return parts;
+        }
+        #isMultipartModel(model) {
+            const multipartTypes = this.#getMultipartParts(model);
+            return multipartTypes.length > 0;
+        }
         modelProperties(model) {
             const result = new StringBuilder();
             for (const [_, prop] of model.properties) {
                 if (!isVoidType(prop.type) &&
                     !isNeverType(prop.type) &&
                     !isNullType(prop.type) &&
-                    !isErrorModel(this.emitter.getProgram(), prop.type))
+                    !isErrorModel(this.emitter.getProgram(), prop.type)) {
                     result.push(code `${this.emitter.emitModelProperty(prop)}`);
+                }
             }
             return result.reduce();
         }
-        #isRecord(type) {
-            return type.kind === "Model" && type.name === "Record" && type.indexer !== undefined;
+        modelLiteralContext(model) {
+            const name = this.emitter.emitDeclarationName(model) || "";
+            return this.modelDeclarationContext(model, name);
+        }
+        modelLiteral(model) {
+            const modelName = this.emitter.getContext().name;
+            reportDiagnostic(this.emitter.getProgram(), {
+                code: "anonymous-model",
+                target: model,
+                format: { emittedName: modelName },
+            });
+            return this.modelDeclaration(model, modelName);
+        }
+        #isInheritedProperty(property) {
+            const visited = [];
+            function isInherited(model, propertyName) {
+                if (visited.includes(model))
+                    return false;
+                visited.push(model);
+                if (model.properties.has(propertyName))
+                    return true;
+                if (model.baseModel === undefined)
+                    return false;
+                return isInherited(model.baseModel, propertyName);
+            }
+            const model = property.model;
+            if (model === undefined || model.baseModel === undefined)
+                return false;
+            return isInherited(model.baseModel, property.name);
         }
         modelPropertyLiteral(property) {
             if (isStatusCode(this.emitter.getProgram(), property))
                 return "";
-            const propertyName = ensureCSharpIdentifier(this.emitter.getProgram(), property, property.name);
-            const [typeName, typeDefault] = 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);
-            // eslint-disable-next-line deprecation/deprecation
+            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 deprecation/deprecation
+                ? // eslint-disable-next-line @typescript-eslint/no-deprecated
                     code `${this.emitter.emitType(property.default)}`
                 : typeDefault;
             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 ${typeName}${property.optional && isValueType(this.emitter.getProgram(), property.type) ? "?" : ""} ${propertyName} { get; ${typeDefault ? "}" : "set; }"}${defaultValue ? ` = ${defaultValue};\n` : "\n"}
+                .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)
+                ? "?"
+                : ""} ${propertyName} { get; ${typeDefault ? "}" : "set; }"}${defaultValue ? ` = ${defaultValue};\n` : "\n"}
     `);
         }
         #findPropertyType(property) {
-            switch (property.type.kind) {
-                case "String":
-                    return [code `string`, `"${property.type.value}"`];
-                case "Boolean":
-                    return [code `bool`, `${property.type.value === true ? true : false}`];
-                case "Number":
-                case "Object":
-                    return [code `object`, undefined];
-                case "Model":
-                    if (this.#isRecord(property.type)) {
-                        return [code `JsonObject`, undefined];
-                    }
-                    return [code `${this.emitter.emitTypeReference(property.type)}`, undefined];
-                default:
-                    return [code `${this.emitter.emitTypeReference(property.type)}`, undefined];
+            return this.#opHelpers.getTypeInfo(this.emitter.getProgram(), property.type);
+        }
+        #isMultipartRequest(operation) {
+            const body = operation.parameters.body;
+            if (body === undefined)
+                return false;
+            return body.bodyKind === "multipart";
+        }
+        #hasMultipartOperation(iface) {
+            for (const [_, operation] of iface.operations) {
+                const [httpOp, _] = getHttpOperation(this.emitter.getProgram(), operation);
+                if (this.#isMultipartRequest(httpOp))
+                    return true;
             }
+            return false;
         }
         modelPropertyReference(property) {
             return code `${this.emitter.emitTypeReference(property.type)}`;
@@ -232,8 +306,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.#licenseHeader}
-      // <auto-generated />
+            const decl = this.emitter.result.declaration(ifaceName, code `${this.#generatedFileHeaderWithNullable}
 
       ${this.#emitUsings()}
 
@@ -252,7 +325,7 @@ export async function $onEmit(context) {
             sourceFile.meta[this.#sourceTypeKey] = CSharpSourceType.Interface;
             const ifaceNamespace = this.#getOrSetBaseNamespace(iface);
             const modelNamespace = `${ifaceNamespace}.Models`;
-            const context = this.#createModelContext(ifaceNamespace, sourceFile);
+            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"]);
@@ -261,6 +334,11 @@ export async function $onEmit(context) {
             ]);
             context.file.imports.set("System.Threading.Tasks", ["System.Threading.Tasks"]);
             context.file.imports.set("Microsoft.AspNetCore.Mvc", ["Microsoft.AspNetCore.Mvc"]);
+            if (this.#hasMultipartOperation(iface)) {
+                context.file.imports.set("Microsoft.AspNetCore.WebUtilities", [
+                    "Microsoft.AspNetCore.WebUtilities",
+                ]);
+            }
             context.file.imports.set(modelNamespace, [modelNamespace]);
             return context;
         }
@@ -269,6 +347,16 @@ export async function $onEmit(context) {
             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 mock = {
+                className: name,
+                interfaceName: `I${name}`,
+                methods: [],
+                namespace: namespace,
+                usings: [`${ifaceNamespace}.Models`],
+            };
             for (const [name, operation] of iface.operations) {
                 const doc = getDoc(this.emitter.getProgram(), operation);
                 const returnTypes = [];
@@ -279,10 +367,22 @@ 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);
-                const opDecl = this.emitter.result.declaration(opName, code `${doc ? `${formatComment(doc)}\n` : ""}${returnType.name === "void" ? "Task" : `Task<${returnType.getTypeReference(context.scope)}>`} ${opName}Async( ${this.#emitInterfaceOperationParameters(operation, opName, "")});`);
+                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);
             }
+            this.#mockRegistrations.set(mock.interfaceName, mock);
             return builder.reduce();
         }
         interfaceOperationDeclarationContext(operation) {
@@ -298,33 +398,68 @@ 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 responseInfo = this.#getOperationResponse(httpOperation);
-            let status = "200";
-            let response = new CSharpType({
-                name: "void",
-                namespace: "System",
-                isBuiltIn: true,
-                isValueType: false,
-            });
-            if (responseInfo !== undefined) {
-                [status, response] = responseInfo;
+            const multipart = this.#isMultipartRequest(httpOperation);
+            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", [
+                    "Microsoft.AspNetCore.WebUtilities",
+                ]);
+                context.file.imports.set("Microsoft.AspNetCore.Http.Extensions", [
+                    "Microsoft.AspNetCore.Http.Extensions",
+                ]);
             }
+            const responseInfo = this.#getOperationResponse(httpOperation);
+            const status = responseInfo?.statusCode ?? 200;
+            const response = responseInfo?.resultType ??
+                new CSharpType({
+                    name: "void",
+                    namespace: "System",
+                    isBuiltIn: true,
+                    isValueType: false,
+                });
             const hasResponseValue = response.name !== "void";
-            const resultString = `${status === "204" ? "NoContent" : "Ok"}`;
-            return this.emitter.result.declaration(operation.name, code `
+            const resultString = `${status === 204 ? "NoContent" : "Ok"}`;
+            if (!this.#isMultipartRequest(httpOperation)) {
+                return this.emitter.result.declaration(operation.name, code `
+        ${doc ? `${formatComment(doc)}` : ""}
+        [${getOperationVerbDecorator(httpOperation)}]
+        [Route("${httpOperation.path}")]
+        ${this.emitter.emitOperationReturnType(operation)}
+        public virtual async Task<IActionResult> ${operationName}(${declParams})
+        {
+          ${hasResponseValue
+                    ? `var result = await ${this.emitter.getContext().resourceName}Impl.${operationName}Async(${getBusinessLogicCallParameters(parameters)});
+          return ${resultString}(result);`
+                    : `await ${this.emitter.getContext().resourceName}Impl.${operationName}Async(${getBusinessLogicCallParameters(parameters)});
+          return ${resultString}();`}
+        }`);
+            }
+            else {
+                return this.emitter.result.declaration(operation.name, code `
         ${doc ? `${formatComment(doc)}` : ""}
         [${getOperationVerbDecorator(httpOperation)}]
         [Route("${httpOperation.path}")]
+        [Consumes("multipart/form-data")]
         ${this.emitter.emitOperationReturnType(operation)}
         public virtual async Task<IActionResult> ${operationName}(${declParams})
         {
+          var boundary = Request.GetMultipartBoundary();
+          if (boundary == null)
+          {
+             return BadRequest("Request missing multipart boundary");
+          }
+
+
+          var reader = new MultipartReader(boundary, Request.Body);
           ${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}();`}
         }`);
+            }
         }
         operationDeclarationContext(operation, name) {
             const resource = getResourceOperation(this.emitter.getProgram(), operation);
@@ -337,20 +472,19 @@ 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);
-            let status = "200";
-            let response = new CSharpType({
-                name: "void",
-                namespace: "System",
-                isBuiltIn: true,
-                isValueType: false,
-            });
-            if (responseInfo !== undefined) {
-                [status, response] = responseInfo;
-            }
+            const status = responseInfo?.statusCode ?? 200;
+            const response = responseInfo?.resultType ??
+                new CSharpType({
+                    name: "void",
+                    namespace: "System",
+                    isBuiltIn: true,
+                    isValueType: false,
+                });
             const hasResponseValue = response.name !== "void";
-            const resultString = `${status === "204" ? "NoContent" : "Ok"}`;
+            const resultString = `${status === 204 ? "NoContent" : "Ok"}`;
             return this.emitter.result.declaration(operation.name, code `
         ${doc ? `${formatComment(doc)}` : ""}
         [${getOperationVerbDecorator(httpOperation)}]
@@ -359,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}();`}
         }`);
         }
@@ -369,20 +503,27 @@ export async function $onEmit(context) {
             const [httpOperation, _] = getHttpOperation(this.emitter.getProgram(), operation);
             return this.#emitOperationResponses(httpOperation);
         }
+        stringTemplate(stringTemplate) {
+            return this.emitter.result.rawCode(stringTemplate.stringValue || "");
+        }
         #getOperationResponse(operation) {
             const validResponses = operation.responses.filter((r) => !isErrorModel(this.emitter.getProgram(), r.type) &&
                 getCSharpStatusCode(r.statusCodes) !== undefined);
             if (validResponses.length < 1)
                 return undefined;
             const response = validResponses[0];
-            const statusCode = getCSharpStatusCode(response.statusCodes);
-            if (statusCode === undefined)
+            const csharpStatusCode = getCSharpStatusCode(response.statusCodes);
+            if (csharpStatusCode === undefined)
                 return undefined;
             const responseType = new HttpMetadata().resolveLogicalResponseType(this.emitter.getProgram(), response);
             const context = this.emitter.getContext();
             const result = getCSharpType(this.emitter.getProgram(), responseType, context.namespace);
             const resultType = result?.type || UnknownType;
-            return [statusCode, resultType];
+            return {
+                csharpStatusCode,
+                resultType,
+                statusCode: response.statusCodes,
+            };
         }
         #emitOperationResponses(operation) {
             const builder = new StringBuilder();
@@ -397,7 +538,8 @@ export async function $onEmit(context) {
                 }
             }
             for (const response of operation.responses) {
-                this.emitter.emitType(response.type);
+                if (!isEmptyResponseModel(this.emitter.getProgram(), response.type))
+                    this.emitter.emitType(response.type);
             }
             return builder.reduce();
         }
@@ -411,45 +553,8 @@ export async function $onEmit(context) {
             const resultType = result?.type || UnknownType;
             return resultType.getTypeReference(context.scope);
         }
-        #emitInterfaceOperationParameters(operation, operationName, resourceName) {
-            const signature = new StringBuilder();
-            const requiredParams = [];
-            const optionalParams = [];
-            let totalParams = 0;
-            for (const [_, parameter] of operation.parameters.properties) {
-                if (parameter.optional)
-                    optionalParams.push(parameter);
-                else
-                    requiredParams.push(parameter);
-                totalParams++;
-            }
-            let i = 1;
-            for (const requiredParam of requiredParams) {
-                signature.push(code `${this.emitter.emitTypeReference(requiredParam.type)} ${ensureCSharpIdentifier(this.emitter.getProgram(), requiredParam, requiredParam.name, NameCasingType.Parameter)}${i++ < totalParams ? ", " : ""}`);
-            }
-            for (const optionalParam of optionalParams) {
-                signature.push(code `${this.emitter.emitTypeReference(optionalParam.type)}? ${ensureCSharpIdentifier(this.emitter.getProgram(), optionalParam, optionalParam.name, NameCasingType.Parameter)}${i++ < totalParams ? ", " : ""}`);
-            }
-            return signature.reduce();
-        }
-        #emitHttpOperationParameters(operation) {
-            const signature = new StringBuilder();
-            const bodyParam = operation.parameters.body;
-            let i = 0;
-            //const pathParameters = operation.parameters.parameters.filter((p) => p.type === "path");
-            for (const parameter of operation.parameters.parameters) {
-                i++;
-                if (parameter.param.type.kind !== "Intrinsic" || parameter.param.type.name !== "never") {
-                    signature.push(code `${this.#emitOperationSignatureParameter(operation, parameter)}${i < operation.parameters.parameters.length || bodyParam !== undefined ? ", " : ""}`);
-                }
-            }
-            if (bodyParam !== undefined) {
-                signature.push(code `${this.emitter.emitTypeReference(this.#metaInfo.getEffectivePayloadType(bodyParam.type, Visibility.Create & Visibility.Update))} body`);
-            }
-            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);
@@ -457,8 +562,7 @@ export async function $onEmit(context) {
                 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.#licenseHeader}
-        // <auto-generated />
+                return this.emitter.result.declaration(unionName, code `${this.#generatedFileHeader}
         
         ${this.#emitUsings()}
         
@@ -476,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`);
@@ -517,55 +621,10 @@ 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);
-            const [emittedType, emittedDefault] = this.#findPropertyType(parameter);
-            // eslint-disable-next-line deprecation/deprecation
-            const defaultValue = parameter.default
-                ? // eslint-disable-next-line deprecation/deprecation
-                    code `${this.emitter.emitType(parameter.default)}`
-                : emittedDefault;
-            return this.emitter.result.rawCode(code `${httpParam.type !== "path" ? this.#emitParameterAttribute(httpParam) : ""}${emittedType} ${emittedName}${defaultValue === undefined ? "" : ` = ${defaultValue}`}`);
-        }
-        #emitOperationCallParameters(operation) {
-            const signature = new StringBuilder();
-            const bodyParam = operation.parameters.body;
-            let i = 0;
-            //const pathParameters = operation.parameters.parameters.filter((p) => p.type === "path");
-            for (const parameter of operation.parameters.parameters) {
-                i++;
-                if (!isNeverType(parameter.param.type) &&
-                    !isNullType(parameter.param.type) &&
-                    !isVoidType(parameter.param.type)) {
-                    signature.push(code `${this.#emitOperationCallParameter(operation, parameter)}${i < operation.parameters.parameters.length || bodyParam !== undefined ? ", " : ""}`);
-                }
-            }
-            if (bodyParam !== undefined) {
-                signature.push(code `body`);
-            }
-            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) {
+        #createModelContext(namespace, file, name) {
             const context = {
                 namespace: namespace,
+                name: name,
                 file: file,
                 scope: file.globalScope,
             };
@@ -574,13 +633,30 @@ 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;
-            const sourceFile = this.emitter.createSourceFile(`controllers/${name}ControllerBase.cs`);
+            const sourceFile = this.emitter.createSourceFile(`controllers/${name}Controller.cs`);
             const namespace = this.#getOrSetBaseNamespace(operation);
             const modelNamespace = `${namespace}.Models`;
             sourceFile.meta[this.#sourceTypeKey] = CSharpSourceType.Controller;
@@ -607,6 +683,7 @@ export async function $onEmit(context) {
             controllers.set(name, context);
             return context;
         }
+        // eslint-disable-next-line no-unused-private-class-members
         #getNamespaceFullName(namespace) {
             return namespace
                 ? ensureCSharpIdentifier(this.emitter.getProgram(), namespace, getNamespaceFullName(namespace))
@@ -621,8 +698,6 @@ export async function $onEmit(context) {
             return scalarType.getTypeReference(this.emitter.getContext().scope);
         }
         scalarDeclaration(scalar, name) {
-            const foo = new Placeholder();
-            foo.setValue;
             const scalarType = getCSharpTypeForScalar(this.emitter.getProgram(), scalar);
             return scalarType.getTypeReference(this.emitter.getContext().scope);
         }
@@ -631,6 +706,12 @@ export async function $onEmit(context) {
                 if (sourceFile === libFile.source)
                     return libFile.emitted;
             }
+            if (this.#mockFiles.length > 0) {
+                for (const mock of this.#mockFiles) {
+                    if (sourceFile === mock.source)
+                        return mock.emitted;
+                }
+            }
             const emittedSourceFile = {
                 path: sourceFile.path,
                 contents: "",
@@ -655,17 +736,21 @@ export async function $onEmit(context) {
         #emitControllerContents(file) {
             const namespace = file.meta.namespace;
             const contents = new StringBuilder();
-            contents.push(`${this.#licenseHeader}\n`);
-            contents.push("// <auto-generated />\n\n");
+            contents.push(`${this.#generatedFileHeaderWithNullable}\n\n`);
             contents.push(code `${this.#emitUsings(file)}\n`);
             contents.push("\n");
             contents.push(`namespace ${namespace}.Controllers\n`);
             contents.push("{\n");
             contents.push("[ApiController]\n");
-            contents.push(`public abstract partial class ${file.meta["resource"]}Base: ControllerBase\n`);
+            contents.push(`public partial class ${file.meta["resource"]}: ControllerBase\n`);
             contents.push("{\n");
             contents.push("\n");
-            contents.push(code `internal abstract I${file.meta.resourceName} ${file.meta.resourceName}Impl { get;}\n`);
+            contents.push(`public ${file.meta["resource"]}(I${file.meta.resourceName} operations)\n`);
+            contents.push("{\n");
+            contents.push(`    ${file.meta.resourceName}Impl = operations;\n`);
+            contents.push("}");
+            contents.push("\n");
+            contents.push(code `internal virtual I${file.meta.resourceName} ${file.meta.resourceName}Impl { get;}\n`);
             for (const decl of file.globalScope.declarations) {
                 contents.push(decl.value + "\n");
             }
@@ -695,6 +780,8 @@ export async function $onEmit(context) {
             }
             return current;
         }
+        // TODO: remove?
+        // eslint-disable-next-line no-unused-private-class-members
         #getTemplateParameters(model) {
             if (!model.templateMapper)
                 return "";
@@ -714,41 +801,17 @@ export async function $onEmit(context) {
                 return params.reduce();
             return "";
         }
-        #coalesceUnionTypes(union) {
-            const defaultValue = new CSharpType({
-                name: "object",
-                namespace: "System",
-                isValueType: false,
-            });
-            let current = undefined;
-            for (const [_, variant] of union.variants.entries()) {
-                let candidate;
-                switch (variant.type.kind) {
-                    case "Boolean":
-                        candidate = new CSharpType({ name: "bool", namespace: "System", isValueType: true });
-                        break;
-                    case "String":
-                        candidate = new CSharpType({ name: "string", namespace: "System", isValueType: false });
-                        break;
-                    case "Union":
-                        candidate = this.#coalesceUnionTypes(variant.type);
-                        break;
-                    case "Scalar":
-                        candidate = getCSharpTypeForScalar(this.emitter.getProgram(), variant.type);
-                        break;
-                    default:
-                        return defaultValue;
-                }
-                current = current ?? candidate;
-                if (current === undefined || !candidate.equals(current))
-                    return defaultValue;
-            }
-            return current ?? defaultValue;
-        }
         writeOutput(sourceFiles) {
             for (const source of this.#libraryFiles) {
                 sourceFiles.push(source.source);
             }
+            if (this.#emitMocks === "all") {
+                if (this.#mockRegistrations.size > 0) {
+                    const mocks = getBusinessLogicImplementations(this.emitter, this.#mockRegistrations, this.#useSwagger, this.#openapiPath);
+                    this.#mockFiles.push(...mocks);
+                    sourceFiles.push(...mocks.flatMap((l) => l.source));
+                }
+            }
             const emittedSourceFiles = [];
             for (const source of sourceFiles) {
                 switch (this.#emitterOutputType) {
@@ -785,11 +848,14 @@ export async function $onEmit(context) {
             return this.#baseNamespace;
         }
     }
-    function processNameSpace(program, target) {
-        const service = getService(program, target);
+    function processNameSpace(program, target, service) {
+        if (!service)
+            service = getService(program, target);
         if (service) {
             for (const [_, model] of target.models) {
-                emitter.emitType(model);
+                if (!isTemplateDeclaration(model) && !isEmptyResponseModel(program, model)) {
+                    emitter.emitType(model);
+                }
             }
             for (const [_, en] of target.enums) {
                 emitter.emitType(en);
@@ -798,10 +864,44 @@ export async function $onEmit(context) {
                 emitter.emitType(sc);
             }
             for (const [_, iface] of target.interfaces) {
-                emitter.emitType(iface);
+                if (!isTemplateDeclaration(iface)) {
+                    emitter.emitType(iface);
+                }
+            }
+            if (target.operations.size > 0) {
+                // Collect interface operations for a business logic interface and controller
+                const nsOps = [];
+                for (const [name, op] of target.operations) {
+                    if (!isTemplateDeclaration(op)) {
+                        nsOps.push([name, op]);
+                    }
+                }
+                const iface = program.checker.createAndFinishType({
+                    node: undefined,
+                    sourceInterfaces: [],
+                    decorators: [],
+                    operations: createRekeyableMap(nsOps),
+                    kind: "Interface",
+                    name: `${target.name}Operations`,
+                    namespace: target,
+                    entityKind: "Type",
+                    isFinished: true,
+                });
+                try {
+                    for (const [_, op] of nsOps) {
+                        op.interface = iface;
+                    }
+                    emitter.emitType(iface);
+                }
+                finally {
+                    for (const [_, op] of nsOps) {
+                        op.interface = undefined;
+                    }
+                    target.interfaces.delete(iface.name);
+                }
             }
-            for (const [_, op] of target.operations) {
-                emitter.emitType(op);
+            for (const [_, sub] of target.namespaces) {
+                processNameSpace(program, sub, service);
             }
         }
         else {
@@ -814,16 +914,18 @@ export async function $onEmit(context) {
     const ns = context.program.checker.getGlobalNamespaceType();
     const options = emitter.getOptions();
     processNameSpace(context.program, ns);
-    await ensureCleanDirectory(context.program, options.emitterOutputDir);
-    await emitter.writeOutput();
-    if (options["skip-format"] === undefined || options["skip-format"] === false) {
-        await execFile("dotnet", [
-            "format",
-            "whitespace",
-            emitter.getOptions().emitterOutputDir,
-            "--include-generated",
-            "--folder",
-        ]);
+    if (!doNotEmit) {
+        await ensureCleanDirectory(context.program, options.emitterOutputDir);
+        await emitter.writeOutput();
+        if (options["skip-format"] === undefined || options["skip-format"] === false) {
+            await execFile("dotnet", [
+                "format",
+                "whitespace",
+                emitter.getOptions().emitterOutputDir,
+                "--include-generated",
+                "--folder",
+            ]);
+        }
     }
 }
 //# sourceMappingURL=service.js.map