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

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

@@ -1,25 +1,36 @@
-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 { Visibility, createMetadataInfo, getHeaderFieldName, getHttpOperation, getHttpPart, isHeader, isPathParam, isQueryParam, isStatusCode, } from "@typespec/http";
 import { getResourceOperation } from "@typespec/rest";
 import { execFile } from "child_process";
-import { getSerializationSourceFiles } from "./boilerplate.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 { 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 { HttpMetadata, UnknownType, coalesceTypes, ensureCSharpIdentifier, ensureCleanDirectory, formatComment, getCSharpIdentifier, getCSharpStatusCode, getCSharpType, getCSharpTypeForIntrinsic, getCSharpTypeForScalar, getModelAttributes, getModelInstantiationName, getOperationVerbDecorator, 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"];
+        #emitMocks = context.options["emit-mocks"];
+        #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,
@@ -40,8 +51,17 @@ export async function $onEmit(context) {
         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 `Model${_unionCounter++}`;
+                    return getCSharpIdentifier(declarationType.name, NameCasingType.Class);
                 case "Operation":
                     return getCSharpIdentifier(declarationType.name, NameCasingType.Class);
                 case "Union":
@@ -60,8 +80,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()}
         
@@ -108,13 +127,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 +148,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 +171,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,54 +205,211 @@ 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();
         }
+        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);
+        }
         #isRecord(type) {
             return type.kind === "Model" && type.name === "Record" && type.indexer !== undefined;
         }
+        #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);
+            const [typeName, typeDefault, 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);
+            // 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) {
+            return this.#getTypeInfoForTsType(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;
+        }
+        #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`, `"${property.type.value}"`];
+                    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`, `${property.type.value === true ? true : false}`];
+                    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];
+                    return [code `object`, undefined, false];
                 case "Model":
-                    if (this.#isRecord(property.type)) {
-                        return [code `JsonObject`, undefined];
+                    if (this.#isRecord(tsType)) {
+                        return [code `JsonObject`, undefined, false];
                     }
-                    return [code `${this.emitter.emitTypeReference(property.type)}`, undefined];
+                    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 `${this.emitter.emitTypeReference(property.type)}`, undefined];
+                    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)}`;
         }
@@ -232,8 +423,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 +442,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 +451,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 +464,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 +484,35 @@ 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, "")});`);
+                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});`);
+                }
+                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,21 +528,32 @@ 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 declParams = !multipart
+                ? this.#emitHttpOperationParameters(httpOperation)
+                : this.#emitHttpOperationParameters(httpOperation, true);
+            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}")]
@@ -320,11 +561,36 @@ 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(${this.#emitOperationCallParameters(httpOperation)});
           return ${resultString}(result);`
-                : `await ${this.emitter.getContext().resourceName}Impl.${operationName}Async(${this.#emitOperationCallParameters(httpOperation)});
+                    : `await ${this.emitter.getContext().resourceName}Impl.${operationName}Async(${this.#emitOperationCallParameters(httpOperation)});
           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, "reader")});
+          return ${resultString}(result);`
+                    : `await ${this.emitter.getContext().resourceName}Impl.${operationName}Async(${this.#emitOperationCallParameters(httpOperation, "reader")});
+          return ${resultString}();`}
+        }`);
+            }
         }
         operationDeclarationContext(operation, name) {
             const resource = getResourceOperation(this.emitter.getProgram(), operation);
@@ -339,18 +605,16 @@ export async function $onEmit(context) {
             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 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)}]
@@ -369,20 +633,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 +668,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,40 +683,63 @@ export async function $onEmit(context) {
             const resultType = result?.type || UnknownType;
             return resultType.getTypeReference(context.scope);
         }
-        #emitInterfaceOperationParameters(operation, operationName, resourceName) {
+        #emitInterfaceOperationParameters(operation, bodyParam) {
             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);
+            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) {
-                signature.push(code `${this.emitter.emitTypeReference(requiredParam.type)} ${ensureCSharpIdentifier(this.emitter.getProgram(), requiredParam, requiredParam.name, NameCasingType.Parameter)}${i++ < totalParams ? ", " : ""}`);
+                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) {
-                signature.push(code `${this.emitter.emitTypeReference(optionalParam.type)}? ${ensureCSharpIdentifier(this.emitter.getProgram(), optionalParam, optionalParam.name, NameCasingType.Parameter)}${i++ < totalParams ? ", " : ""}`);
+                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) {
+        #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");
-            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 ? ", " : ""}`);
+            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 ? ", " : ""}`);
                 }
             }
-            if (bodyParam !== undefined) {
-                signature.push(code `${this.emitter.emitTypeReference(this.#metaInfo.getEffectivePayloadType(bodyParam.type, Visibility.Create & Visibility.Update))} body`);
+            i = 0;
+            for (const parameter of optionalParams) {
+                signature.push(code `${this.#emitOperationSignatureParameter(operation, parameter)}${++i < optionalParams.length ? ", " : ""}`);
             }
             return signature.reduce();
         }
@@ -457,8 +752,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()}
         
@@ -521,29 +815,66 @@ export async function $onEmit(context) {
             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
+            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 deprecation/deprecation
+                ? // 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}`}`);
         }
-        #emitOperationCallParameters(operation) {
-            const signature = new StringBuilder();
+        #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");
-            for (const parameter of operation.parameters.parameters) {
+            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)) {
-                    signature.push(code `${this.#emitOperationCallParameter(operation, parameter)}${i < operation.parameters.parameters.length || bodyParam !== undefined ? ", " : ""}`);
+                    !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 ? ", " : ""}`);
+                    }
                 }
             }
-            if (bodyParam !== undefined) {
-                signature.push(code `body`);
+            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();
         }
@@ -563,9 +894,10 @@ export async function $onEmit(context) {
                     return "";
             }
         }
-        #createModelContext(namespace, file) {
+        #createModelContext(namespace, file, name) {
             const context = {
                 namespace: namespace,
+                name: name,
                 file: file,
                 scope: file.globalScope,
             };
@@ -580,7 +912,7 @@ export async function $onEmit(context) {
             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 +939,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 +954,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 +962,18 @@ 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)
+                        return mock.emitted;
+                }
+            }
             const emittedSourceFile = {
                 path: sourceFile.path,
                 contents: "",
@@ -655,17 +998,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.#generatedFileHeader}\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(`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 abstract I${file.meta.resourceName} ${file.meta.resourceName}Impl { get;}\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 +1042,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 "";
@@ -715,40 +1064,91 @@ export async function $onEmit(context) {
             return "";
         }
         #coalesceUnionTypes(union) {
-            const defaultValue = new CSharpType({
-                name: "object",
-                namespace: "System",
-                isValueType: false,
-            });
+            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;
-            for (const [_, variant] of union.variants.entries()) {
-                let candidate;
-                switch (variant.type.kind) {
+            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(variant.type);
+                        candidate = this.#coalesceUnionTypes(type);
                         break;
                     case "Scalar":
-                        candidate = getCSharpTypeForScalar(this.emitter.getProgram(), variant.type);
+                        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.equals(current))
+                if (current === undefined || (candidate !== undefined && !candidate.equals(current)))
                     return defaultValue;
             }
-            return current ?? 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);
+                    this.#mockFiles.push(...mocks);
+                    sourceFiles.push(...mocks.flatMap((l) => l.source));
+                }
+            }
             const emittedSourceFiles = [];
             for (const source of sourceFiles) {
                 switch (this.#emitterOutputType) {
@@ -785,11 +1185,34 @@ export async function $onEmit(context) {
             return this.#baseNamespace;
         }
     }
-    function processNameSpace(program, target) {
-        const service = getService(program, target);
+    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);
         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 +1221,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 +1271,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