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

package/dist/src/lib/utils.js

@@ -1,6 +1,6 @@
 import { NoTarget, getFriendlyName, isNullType, isNumericType, isTemplateInstance, isUnknownType, isVoidType, } from "@typespec/compiler";
-import { StringBuilder } from "@typespec/compiler/emitter-framework";
-import { Visibility, createMetadataInfo, isBody, isBodyRoot, isMetadata, isStatusCode, } from "@typespec/http";
+import { StringBuilder, code, } from "@typespec/compiler/emitter-framework";
+import { Visibility, createMetadataInfo, getHeaderFieldName, isBody, isBodyRoot, isHeader, isMetadata, isPathParam, isQueryParam, isStatusCode, } from "@typespec/http";
 import { camelCase, pascalCase } from "change-case";
 import { getAttributes } from "./attributes.js";
 import { BooleanValue, CSharpType, NameCasingType, NullValue, NumericValue, StringValue, } from "./interfaces.js";
@@ -21,7 +21,7 @@ export function getCSharpTypeForScalar(program, scalar) {
         target: scalar,
     });
     const result = new CSharpType({
-        name: "Object",
+        name: "object",
         namespace: "System",
         isBuiltIn: true,
         isValueType: false,
@@ -82,6 +82,7 @@ export function getCSharpType(program, type, namespace) {
                     namespace: namespace || "Models",
                     isBuiltIn: false,
                     isValueType: false,
+                    isClass: true,
                 }),
             };
         case "Enum":
@@ -90,7 +91,7 @@ export function getCSharpType(program, type, namespace) {
                     name: ensureCSharpIdentifier(program, type, type.name, NameCasingType.Class),
                     namespace: `${namespace}.Models`,
                     isBuiltIn: false,
-                    isValueType: false,
+                    isValueType: true,
                 }),
             };
         case "Model":
@@ -105,6 +106,8 @@ export function getCSharpType(program, type, namespace) {
                         namespace: itemType.namespace,
                         isBuiltIn: itemType.isBuiltIn,
                         isValueType: false,
+                        isClass: itemType.isClass,
+                        isCollection: true,
                     }),
                 };
             }
@@ -118,6 +121,7 @@ export function getCSharpType(program, type, namespace) {
                     namespace: `${namespace}.Models`,
                     isBuiltIn: false,
                     isValueType: false,
+                    isClass: true,
                 }),
             };
         default:
@@ -474,6 +478,23 @@ export function ensureCSharpIdentifier(program, target, name, context = NameCasi
 export function getModelAttributes(program, entity, cSharpName) {
     return getAttributes(program, entity, cSharpName);
 }
+export function getModelDeclarationName(program, model, defaultSuffix) {
+    if (model.name !== null && model.name.length > 0) {
+        return ensureCSharpIdentifier(program, model, model.name, NameCasingType.Class);
+    }
+    if (model.sourceModel && model.sourceModel.name && model.sourceModel.name.length > 0) {
+        return ensureCSharpIdentifier(program, model, `${model.sourceModel.name}${defaultSuffix}`, NameCasingType.Class);
+    }
+    if (model.sourceModels.length > 0) {
+        const sourceNames = model.sourceModels
+            .filter((m) => m.model.name !== undefined && m.model.name.length > 0)
+            .flatMap((m) => ensureCSharpIdentifier(program, model, m.model.name, NameCasingType.Class));
+        if (sourceNames.length > 0) {
+            return `${sourceNames.join()}${defaultSuffix}`;
+        }
+    }
+    return `Model${defaultSuffix}`;
+}
 export function getModelInstantiationName(program, model, name) {
     const friendlyName = getFriendlyName(program, model);
     if (friendlyName && friendlyName.length > 0)
@@ -563,6 +584,8 @@ export class HttpMetadata {
         });
         switch (responseType.kind) {
             case "Model":
+                if (responseType.indexer && responseType.indexer.key.name !== "string")
+                    return responseType;
                 const bodyProp = new ModelInfo().filterAllProperties(program, responseType, (p) => isBody(program, p) || isBodyRoot(program, p));
                 if (bodyProp !== undefined)
                     return metaInfo.getEffectivePayloadType(bodyProp.type, Visibility.Read);
@@ -642,4 +665,522 @@ export function getCSharpStatusCode(entry) {
             return undefined;
     }
 }
+export function isEmptyResponseModel(program, model) {
+    if (model.kind !== "Model")
+        return false;
+    if (model.properties.size === 0)
+        return true;
+    return model.properties.size === 1 && isStatusCode(program, [...model.properties.values()][0]);
+}
+export function isContentTypeHeader(program, parameter) {
+    return (isHeader(program, parameter) &&
+        (parameter.name === "contentType" || getHeaderFieldName(program, parameter) === "Content-type"));
+}
+export function isValidParameter(program, parameter) {
+    return (!isContentTypeHeader(program, parameter) &&
+        (parameter.type.kind !== "Intrinsic" || parameter.type.name !== "never") &&
+        parameter.model?.name === "");
+}
+/** Determine whether the given parameter is http metadata */
+export function isHttpMetadata(program, property) {
+    return (isPathParam(program, property) || isHeader(program, property) || isQueryParam(program, property));
+}
+export function getBusinessLogicCallParameters(parameters) {
+    const builder = new StringBuilder();
+    const blParameters = parameters.filter((p) => p.operationKind === "BusinessLogic" || p.operationKind === "All");
+    let i = 0;
+    for (const param of blParameters) {
+        builder.push(code `${getBusinessLogicCallParameter(param)}${++i < blParameters.length ? ", " : ""}`);
+    }
+    return builder.reduce();
+}
+export function getBusinessLogicDeclParameters(parameters) {
+    const builder = new StringBuilder();
+    const blParameters = parameters.filter((p) => p.operationKind === "BusinessLogic" || p.operationKind === "All");
+    let i = 0;
+    for (const param of blParameters) {
+        builder.push(code `${getBusinessLogicSignatureParameter(param)}${++i < blParameters.length ? ", " : ""}`);
+    }
+    return builder.reduce();
+}
+export function getHttpDeclParameters(parameters) {
+    const builder = new StringBuilder();
+    const blParameters = parameters.filter((p) => p.operationKind === "Http" || p.operationKind === "All");
+    let i = 0;
+    for (const param of blParameters) {
+        builder.push(code `${getHttpSignatureParameter(param)}${++i < blParameters.length ? ", " : ""}`);
+    }
+    return builder.reduce();
+}
+export function getBusinessLogicCallParameter(param) {
+    const builder = new StringBuilder();
+    builder.push(code `${param.callName}`);
+    return builder.reduce();
+}
+export function getBusinessLogicSignatureParameter(param) {
+    const builder = new StringBuilder();
+    builder.push(code `${param.typeName}${param.optional || param.nullable ? "? " : " "}${param.name}`);
+    return builder.reduce();
+}
+export function getHttpSignatureParameter(param) {
+    const builder = new StringBuilder();
+    builder.push(code `${getHttpParameterDecorator(param)}${getBusinessLogicSignatureParameter(param)}${param.defaultValue === undefined ? "" : code ` = ${typeof param.defaultValue === "boolean" ? code `${param.defaultValue.toString()}` : code `${param.defaultValue}`}`}`);
+    return builder.reduce();
+}
+export function getHttpParameterDecorator(parameter) {
+    switch (parameter.httpParameterKind) {
+        case "query":
+            return code `[FromQuery${parameter.httpParameterName ? code `(Name="${parameter.httpParameterName}")` : ""}] `;
+        case "header":
+            return code `[FromHeader${parameter.httpParameterName ? code `(Name="${parameter.httpParameterName}")` : ""}] `;
+        default:
+            return "";
+    }
+}
+export function getParameterKind(parameter) {
+    switch (parameter.type) {
+        case "path":
+            return "path";
+        case "cookie":
+        case "header":
+            return "header";
+        case "query":
+            return "query";
+    }
+}
+export function canHaveDefault(program, type) {
+    switch (type.kind) {
+        case "Boolean":
+        case "EnumMember":
+        case "Enum":
+        case "Number":
+        case "String":
+        case "Scalar":
+        case "StringTemplate":
+            return true;
+        case "ModelProperty":
+            return canHaveDefault(program, type.type);
+        default:
+            return false;
+    }
+}
+export class CSharpOperationHelpers {
+    constructor(inEmitter) {
+        this.emitter = inEmitter;
+        this.#anonymousModels = new Map();
+        this.#opCache = new Map();
+    }
+    emitter;
+    #anonymousModels;
+    #opCache;
+    getParameters(program, operation) {
+        function safeConcat(...names) {
+            return names
+                .filter((n) => n !== undefined && n !== null && n.length > 0)
+                .flatMap((s) => getCSharpIdentifier(s, NameCasingType.Class))
+                .join();
+        }
+        const cached = this.#opCache.get(operation.operation);
+        if (cached)
+            return cached;
+        const bodyParam = operation.parameters.body;
+        const isExplicitBodyParam = bodyParam?.property !== undefined;
+        const result = [];
+        if (operation.verb === "get" && operation.parameters.body !== undefined) {
+            reportDiagnostic(program, {
+                code: "get-request-body",
+                target: operation.operation,
+                format: {},
+            });
+            this.#opCache.set(operation.operation, result);
+            return result;
+        }
+        const validParams = operation.parameters.parameters.filter((p) => isValidParameter(program, 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) {
+            let { typeReference: paramType, defaultValue: paramValue } = this.getTypeInfo(program, parameter.param.type);
+            // cSharp does not allow array defaults in operation parameters
+            if (!canHaveDefault(program, parameter.param)) {
+                paramValue = undefined;
+            }
+            const paramName = ensureCSharpIdentifier(program, parameter.param, parameter.param.name, NameCasingType.Parameter);
+            result.push({
+                isExplicitBody: false,
+                name: paramName,
+                callName: paramName,
+                optional: false,
+                typeName: paramType,
+                defaultValue: paramValue,
+                httpParameterKind: getParameterKind(parameter),
+                httpParameterName: parameter.name,
+                nullable: false,
+                operationKind: "All",
+            });
+        }
+        const overrideParameters = getExplicitBodyParameters(program, operation);
+        if (overrideParameters !== undefined) {
+            for (const overrideParam of overrideParameters) {
+                result.push(overrideParam);
+            }
+        }
+        else if (bodyParam !== undefined && isExplicitBodyParam) {
+            let { typeReference: bodyType, defaultValue: bodyValue, nullableType: isNullable, } = this.getTypeInfo(program, bodyParam.type);
+            if (!canHaveDefault(program, bodyParam.type)) {
+                bodyValue = undefined;
+            }
+            result.push({
+                isExplicitBody: true,
+                httpParameterKind: "body",
+                name: "body",
+                callName: "body",
+                typeName: bodyType,
+                nullable: isNullable,
+                defaultValue: bodyValue,
+                optional: bodyParam.property?.optional ?? false,
+                operationKind: "All",
+            });
+        }
+        else if (bodyParam !== undefined) {
+            switch (bodyParam.type.kind) {
+                case "Model":
+                    let tsBody = bodyParam.type;
+                    if (!bodyParam.type.name) {
+                        tsBody = program.checker.cloneType(bodyParam.type, {
+                            name: safeConcat(operation.operation.interface?.name, operation.operation.name, "Request"),
+                        });
+                    }
+                    const { typeReference: bodyType } = this.getTypeInfo(program, tsBody);
+                    const bodyName = ensureCSharpIdentifier(program, bodyParam.type, "body", NameCasingType.Parameter);
+                    result.push({
+                        isExplicitBody: false,
+                        httpParameterKind: "body",
+                        name: bodyName,
+                        callName: bodyName,
+                        typeName: bodyType,
+                        nullable: false,
+                        defaultValue: undefined,
+                        optional: false,
+                        operationKind: "Http",
+                    });
+                    for (const [propName, propDef] of bodyParam.type.properties) {
+                        let { typeReference: csType, defaultValue: csValue, nullableType: isNullable, } = this.getTypeInfo(program, propDef.type);
+                        // cSharp does not allow array defaults in operation parameters
+                        if (!canHaveDefault(program, propDef)) {
+                            csValue = undefined;
+                        }
+                        const paramName = ensureCSharpIdentifier(program, propDef, propName, NameCasingType.Parameter);
+                        const refName = ensureCSharpIdentifier(program, propDef, propName, NameCasingType.Property);
+                        result.push({
+                            isExplicitBody: false,
+                            httpParameterKind: "body",
+                            name: paramName,
+                            callName: `body.${refName}`,
+                            typeName: csType,
+                            nullable: isNullable,
+                            defaultValue: csValue,
+                            optional: propDef.optional,
+                            operationKind: "BusinessLogic",
+                        });
+                    }
+                    break;
+                case "ModelProperty":
+                    {
+                        let { typeReference: csType, defaultValue: csValue, nullableType: isNullable, } = this.getTypeInfo(program, bodyParam.type.type);
+                        if (!canHaveDefault(program, bodyParam.type)) {
+                            csValue = undefined;
+                        }
+                        const optName = ensureCSharpIdentifier(program, bodyParam.type.type, bodyParam.type.name, NameCasingType.Parameter);
+                        result.push({
+                            isExplicitBody: true,
+                            httpParameterKind: "body",
+                            name: optName,
+                            callName: optName,
+                            typeName: csType,
+                            nullable: isNullable,
+                            defaultValue: csValue,
+                            optional: bodyParam.type.optional,
+                            operationKind: "All",
+                        });
+                    }
+                    break;
+                default: {
+                    let { typeReference: csType, defaultValue: csValue, nullableType: isNullable, } = this.getTypeInfo(program, bodyParam.type);
+                    if (!canHaveDefault(program, bodyParam.type)) {
+                        csValue = undefined;
+                    }
+                    result.push({
+                        isExplicitBody: true,
+                        httpParameterKind: "body",
+                        name: "body",
+                        callName: "body",
+                        typeName: csType,
+                        nullable: isNullable,
+                        defaultValue: csValue,
+                        optional: false,
+                        operationKind: "All",
+                    });
+                }
+            }
+        }
+        for (const parameter of optionalParams) {
+            const { typeReference: paramType, defaultValue: paramValue, nullableType: isNullable, } = this.getTypeInfo(program, parameter.param.type);
+            const optName = ensureCSharpIdentifier(program, parameter.param, parameter.param.name, NameCasingType.Parameter);
+            result.push({
+                isExplicitBody: false,
+                name: optName,
+                callName: optName,
+                optional: true,
+                typeName: paramType,
+                defaultValue: paramValue,
+                httpParameterKind: getParameterKind(parameter),
+                httpParameterName: parameter.name,
+                nullable: isNullable,
+                operationKind: "All",
+            });
+        }
+        this.#opCache.set(operation.operation, result);
+        return result;
+    }
+    getTypeInfo(program, tsType) {
+        const myEmitter = this.emitter;
+        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(myEmitter.getProgram(), {
+                code: "invalid-interpolation",
+                target: span,
+                format: {},
+            });
+            return "";
+        }
+        switch (tsType.kind) {
+            case "String":
+                return {
+                    typeReference: code `string`,
+                    defaultValue: `"${tsType.value}"`,
+                    nullableType: false,
+                };
+            case "StringTemplate":
+                const template = tsType;
+                if (template.stringValue !== undefined)
+                    return {
+                        typeReference: code `string`,
+                        defaultValue: `"${template.stringValue}"`,
+                        nullableType: false,
+                    };
+                const spanResults = [];
+                for (const span of template.spans) {
+                    spanResults.push(extractStringValue(span, span));
+                }
+                return {
+                    typeReference: code `string`,
+                    defaultValue: `"${spanResults.join("")}"`,
+                    nullableType: false,
+                };
+            case "Boolean":
+                return {
+                    typeReference: code `bool`,
+                    defaultValue: `${tsType.value === true ? true : false}`,
+                    nullableType: false,
+                };
+            case "Number":
+                const [type, value] = findNumericType(tsType);
+                return { typeReference: code `${type}`, defaultValue: `${value}`, nullableType: false };
+            case "Tuple":
+                const defaults = [];
+                const [csharpType, isObject] = coalesceTsTypes(program, tsType.values);
+                if (isObject)
+                    return { typeReference: "object[]", defaultValue: undefined, nullableType: false };
+                for (const value of tsType.values) {
+                    const { defaultValue: itemDefault } = this.getTypeInfo(program, value);
+                    defaults.push(itemDefault);
+                }
+                return {
+                    typeReference: code `${csharpType.getTypeReference()}[]`,
+                    defaultValue: `[${defaults.join(", ")}]`,
+                    nullableType: csharpType.isNullable,
+                };
+            case "Object":
+                return { typeReference: code `object`, defaultValue: undefined, nullableType: false };
+            case "Model":
+                let modelResult;
+                const cachedResult = this.#anonymousModels.get(tsType);
+                if (cachedResult) {
+                    return cachedResult;
+                }
+                if (isRecord(tsType)) {
+                    modelResult = { typeReference: code `JsonObject`, nullableType: false };
+                }
+                else {
+                    modelResult = {
+                        typeReference: code `${this.emitter.emitTypeReference(tsType)}`,
+                        nullableType: false,
+                    };
+                }
+                this.#anonymousModels.set(tsType, modelResult);
+                return modelResult;
+            case "ModelProperty":
+                return this.getTypeInfo(program, tsType.type);
+            case "Enum":
+                return {
+                    typeReference: code `${this.emitter.emitTypeReference(tsType)}`,
+                    nullableType: false,
+                };
+            case "EnumMember":
+                if (typeof tsType.value === "number") {
+                    const stringValue = tsType.value.toString();
+                    if (stringValue.includes(".") || stringValue.includes("e"))
+                        return { typeReference: "double", defaultValue: stringValue, nullableType: false };
+                    return { typeReference: "int", defaultValue: stringValue, nullableType: false };
+                }
+                if (typeof tsType.value === "string") {
+                    return { typeReference: "string", defaultValue: tsType.value, nullableType: false };
+                }
+                return { typeReference: code `object`, nullableType: false };
+            case "Union":
+                return this.getUnionInfo(program, tsType);
+            case "UnionVariant":
+                return this.getTypeInfo(program, tsType.type);
+            default:
+                return {
+                    typeReference: code `${this.emitter.emitTypeReference(tsType)}`,
+                    nullableType: false,
+                };
+        }
+    }
+    getUnionInfo(program, union) {
+        const propResult = getNonNullableTsType(union);
+        if (propResult === undefined) {
+            return {
+                typeReference: code `${this.emitter.emitTypeReference(union)}`,
+                nullableType: [...union.variants.values()].some((v) => isNullType(v.type)),
+            };
+        }
+        const candidate = this.getTypeInfo(program, propResult.type);
+        candidate.nullableType = propResult.nullable;
+        return candidate;
+    }
+}
+export function getExplicitBodyParameters(program, httpOperation) {
+    if (httpOperation.parameters.body && httpOperation.parameters.body.bodyKind === "multipart") {
+        return [
+            {
+                name: "reader",
+                callName: "reader",
+                nullable: false,
+                optional: false,
+                typeName: "MultipartReader",
+                isExplicitBody: false,
+                httpParameterKind: "body",
+                operationKind: "BusinessLogic",
+            },
+        ];
+    }
+    return undefined;
+}
+export function findNumericType(type) {
+    const stringValue = type.valueAsString;
+    if (stringValue.includes(".") || stringValue.includes("e"))
+        return ["double", stringValue];
+    return ["int", stringValue];
+}
+export function coalesceUnionTypes(program, union) {
+    const [result, _] = coalesceTsTypes(program, [...union.variants.values()].flatMap((v) => v.type));
+    return result;
+}
+export function 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;
+}
+export function coalesceTsTypes(program, types) {
+    const defaultValue = [
+        new CSharpType({
+            name: "object",
+            namespace: "System",
+            isBuiltIn: true,
+            isValueType: false,
+        }),
+        true,
+    ];
+    let current = undefined;
+    let nullable = false;
+    for (const type of types) {
+        let candidate = undefined;
+        switch (type.kind) {
+            case "Boolean":
+                candidate = new CSharpType({ name: "bool", namespace: "System", isValueType: true });
+                break;
+            case "StringTemplate":
+            case "String":
+                candidate = new CSharpType({ name: "string", namespace: "System", isValueType: false });
+                break;
+            case "Number":
+                const stringValue = type.valueAsString;
+                if (stringValue.includes(".") || stringValue.includes("e")) {
+                    candidate = new CSharpType({
+                        name: "double",
+                        namespace: "System",
+                        isValueType: true,
+                    });
+                }
+                else {
+                    candidate = new CSharpType({ name: "int", namespace: "System", isValueType: true });
+                }
+                break;
+            case "Union":
+                candidate = coalesceUnionTypes(program, type);
+                break;
+            case "Scalar":
+                candidate = getCSharpTypeForScalar(program, type);
+                break;
+            case "Intrinsic":
+                if (isNullType(type)) {
+                    nullable = true;
+                    candidate = current;
+                }
+                else {
+                    return defaultValue;
+                }
+                break;
+            default:
+                return defaultValue;
+        }
+        current = current ?? candidate;
+        if (current === undefined || (candidate !== undefined && !candidate.equals(current)))
+            return defaultValue;
+    }
+    if (current !== undefined && nullable === true)
+        current.isNullable = true;
+    return current === undefined ? defaultValue : [current, false];
+}
+export function isRecord(type) {
+    return type.kind === "Model" && type.name === "Record" && type.indexer !== undefined;
+}
 //# sourceMappingURL=utils.js.map