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

package/dist/src/service.js

@@ -1,5 +1,6 @@
-import { getDoc, getNamespaceFullName, getService, isErrorModel, isNeverType, isNullType, isVoidType, } from "@typespec/compiler";
+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, getHttpOperation, isStatusCode, } from "@typespec/http";
 import { getResourceOperation } from "@typespec/rest";
 import { execFile } from "child_process";
@@ -7,7 +8,7 @@ import { getSerializationSourceFiles } from "./boilerplate.js";
 import { CSharpSourceType, CSharpType, NameCasingType, } from "./interfaces.js";
 import { reportDiagnostic } from "./lib.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();
@@ -40,8 +41,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":
@@ -108,13 +118,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) {
@@ -150,14 +162,14 @@ export async function $onEmit(context) {
             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) {
             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;
         }
@@ -177,48 +189,178 @@ export async function $onEmit(context) {
                 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);
+            const attributes = getModelAttributes(this.emitter.getProgram(), property, propertyName);
             // eslint-disable-next-line @typescript-eslint/no-deprecated
             const defaultValue = property.default
                 ? // eslint-disable-next-line @typescript-eslint/no-deprecated
                     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);
+        }
+        #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 `${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];
                     }
-                    return [code `${this.emitter.emitTypeReference(property.type)}`, undefined];
+                    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)}`;
         }
@@ -252,7 +394,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"]);
@@ -369,6 +511,9 @@ 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);
@@ -397,7 +542,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();
         }
@@ -425,10 +571,12 @@ export async function $onEmit(context) {
             }
             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 ? ", " : ""}`);
             }
             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();
         }
@@ -521,7 +669,9 @@ 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);
+            let [emittedType, emittedDefault, _] = this.#findPropertyType(parameter);
+            if (emittedType.toString().endsWith("[]"))
+                emittedDefault = undefined;
             // eslint-disable-next-line @typescript-eslint/no-deprecated
             const defaultValue = parameter.default
                 ? // eslint-disable-next-line @typescript-eslint/no-deprecated
@@ -529,21 +679,41 @@ export async function $onEmit(context) {
                 : emittedDefault;
             return this.emitter.result.rawCode(code `${httpParam.type !== "path" ? this.#emitParameterAttribute(httpParam) : ""}${emittedType} ${emittedName}${defaultValue === undefined ? "" : ` = ${defaultValue}`}`);
         }
+        #getBodyParameters(operation) {
+            const bodyParam = operation.parameters.body;
+            if (bodyParam === undefined)
+                return undefined;
+            if (bodyParam.property !== undefined)
+                return [bodyParam.property];
+            if (bodyParam.type.kind !== "Model" || bodyParam.type.properties.size < 1)
+                return undefined;
+            return [...bodyParam.type.properties.values()];
+        }
         #emitOperationCallParameters(operation) {
             const signature = new StringBuilder();
-            const bodyParam = operation.parameters.body;
             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) {
                 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 ? ", " : ""}`);
+                    signature.push(code `${this.#emitOperationCallParameter(operation, parameter)}${i < operation.parameters.parameters.length || bodyParameters !== undefined ? ", " : ""}`);
                 }
             }
-            if (bodyParam !== undefined) {
-                signature.push(code `body`);
+            if (bodyParameters !== undefined) {
+                if (bodyParameters.length === 1) {
+                    signature.push(code `body`);
+                }
+                else {
+                    let j = 0;
+                    for (const parameter of bodyParameters) {
+                        j++;
+                        const propertyName = ensureCSharpIdentifier(this.emitter.getProgram(), parameter, parameter.name, NameCasingType.Property);
+                        signature.push(code `body?.${propertyName}${j < bodyParameters.length ? ", " : ""}`);
+                    }
+                }
             }
             return signature.reduce();
         }
@@ -563,9 +733,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,
             };
@@ -716,35 +887,76 @@ 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) {
@@ -786,11 +998,19 @@ 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 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);
@@ -799,10 +1019,36 @@ export async function $onEmit(context) {
                 emitter.emitType(sc);
             }
             for (const [_, iface] of target.interfaces) {
+                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,
+                });
+                for (const [_, op] of nsOps) {
+                    op.interface = iface;
+                }
                 emitter.emitType(iface);
             }
-            for (const [_, op] of target.operations) {
-                emitter.emitType(op);
+            for (const [_, sub] of target.namespaces) {
+                processNameSpace(program, sub, service);
             }
         }
         else {