@azure-tools/typespec-ts 0.13.0 → 0.13.1

package/dist/src/modular/buildCodeModel.js

@@ -1,8 +1,8 @@
 import { getPagedResult, isFixed } from "@azure-tools/typespec-azure-core";
-import { getDoc, getFriendlyName, getMaxLength, getMaxValue, getMinLength, getMinValue, getPattern, getSummary, getVisibility, ignoreDiagnostics, isErrorModel, isNeverType, getEffectiveModelType, getDiscriminator, isKey, isStringType, getPropertyType, isNumericType, getFormat, getMinItems, getMaxItems, listServices, isNullType, SyntaxKind, getProjectedName } from "@typespec/compiler";
+import { getDoc, getFriendlyName, getMaxLength, getMaxValue, getMinLength, getMinValue, getPattern, getSummary, getVisibility, ignoreDiagnostics, isErrorModel, isNeverType, getEffectiveModelType, getDiscriminator, isKey, isStringType, getPropertyType, isNumericType, getFormat, getMinItems, getMaxItems, listServices, getProjectedName, isNullType } from "@typespec/compiler";
 import { getAuthentication, getHeaderFieldName, getHttpOperation, getPathParamName, getQueryParamName, getServers, isStatusCode, isHeader } from "@typespec/http";
 import { getAddedOnVersions } from "@typespec/versioning";
-import { listClients, listOperationGroups, listOperationsInOperationGroup, isApiVersion, getDefaultApiVersion, getClientNamespaceString, createSdkContext } from "@azure-tools/typespec-client-generator-core";
+import { listClients, listOperationGroups, listOperationsInOperationGroup, isApiVersion, getDefaultApiVersion, getClientNamespaceString, createSdkContext, getSdkUnion, getAllModels, getSdkSimpleType } from "@azure-tools/typespec-client-generator-core";
 import { getResourceOperation } from "@typespec/rest";
 import { transformRLCOptions } from "../transform/transfromRLCOptions.js";
 import { camelToSnakeCase, toCamelCase } from "../casingUtils.js";
@@ -47,12 +47,12 @@ function isLro(_program, operation) {
     }
     return false;
 }
-function handleDiscriminator(program, type, model) {
-    const discriminator = getDiscriminator(program, type);
+function handleDiscriminator(context, type, model) {
+    const discriminator = getDiscriminator(context.program, type);
     if (discriminator) {
         let discriminatorProperty;
         for (const childModel of type.derivedModels) {
-            const modelType = getType(program, childModel);
+            const modelType = getType(context, childModel);
             for (const property of modelType.properties) {
                 if (property.restApiName === discriminator.propertyName) {
                     modelType.discriminatorValue = property.type.value;
@@ -77,6 +77,7 @@ function handleDiscriminator(program, type, model) {
     }
 }
 function getEffectiveSchemaType(program, type) {
+    var _a;
     function isSchemaProperty(property) {
         const headerInfo = getHeaderFieldName(program, property);
         const queryInfo = getQueryParamName(program, property);
@@ -84,37 +85,78 @@ function getEffectiveSchemaType(program, type) {
         const statusCodeinfo = isStatusCode(program, property);
         return !(headerInfo || queryInfo || pathInfo || statusCodeinfo);
     }
-    const effective = getEffectiveModelType(program, type, isSchemaProperty);
+    let effective;
+    if (type.kind === "Union") {
+        const nonNullOptions = [...type.variants.values()]
+            .map((x) => x.type)
+            .filter((t) => !isNullType(t));
+        if (nonNullOptions.length === 1 && ((_a = nonNullOptions[0]) === null || _a === void 0 ? void 0 : _a.kind) === "Model") {
+            effective = getEffectiveModelType(program, nonNullOptions[0]);
+        }
+        return type;
+    }
+    else {
+        effective = getEffectiveModelType(program, type, isSchemaProperty);
+    }
     if (effective.name) {
         return effective;
     }
     return type;
 }
-function getType(program, type) {
+function isEmptyModel(type) {
+    // object, {}, Model{} all will be treated as empty model
+    return (type.kind === "Model" &&
+        type.properties.size === 0 &&
+        !type.baseModel &&
+        type.derivedModels.length === 0 &&
+        !type.indexer);
+}
+function processModelProperties(context, newValue, model) {
+    // need to do properties after insertion to avoid infinite recursion
+    for (const property of model.properties.values()) {
+        if (isStatusCode(context.program, property) ||
+            isNeverType(property.type) ||
+            isHeader(context.program, property)) {
+            continue;
+        }
+        newValue.properties.push(emitProperty(context, property));
+    }
+    // need to do discriminator outside `emitModel` to avoid infinite recursion
+    handleDiscriminator(context, model, newValue);
+}
+function getType(context, type, options = {}) {
     // don't cache simple type(string, int, etc) since decorators may change the result
-    const enableCache = !isSimpleType(program, type);
-    const effectiveModel = type.kind === "Model" ? getEffectiveSchemaType(program, type) : type;
+    const enableCache = !isSimpleType(context.program, type) && !isEmptyModel(type);
+    const effectiveModel = !options.disableEffectiveModel &&
+        (type.kind === "Model" || type.kind === "Union")
+        ? getEffectiveSchemaType(context.program, type)
+        : type;
     if (enableCache) {
         const cached = typesMap.get(effectiveModel);
         if (cached) {
             return cached;
         }
     }
-    let newValue = emitType(program, type);
+    let newValue;
+    if (isEmptyModel(type)) {
+        // do not generate model for empty model, treat it as any
+        newValue = { type: "any" };
+    }
+    else {
+        newValue = emitType(context, type);
+    }
     if (enableCache) {
         typesMap.set(effectiveModel, newValue);
-        if (type.kind === "Model") {
-            // need to do properties after insertion to avoid infinite recursion
-            for (const property of type.properties.values()) {
-                if (isStatusCode(program, property) ||
-                    isNeverType(property.type) ||
-                    isHeader(program, property)) {
-                    continue;
+        if (type.kind === "Union") {
+            for (const t of type.variants.values()) {
+                if (t.type.kind === "Model") {
+                    processModelProperties(context, newValue, t.type);
                 }
-                newValue.properties.push(emitProperty(program, property));
             }
-            // need to do discriminator outside `emitModel` to avoid infinite recursion
-            handleDiscriminator(program, type, newValue);
+        }
+        if (type.kind === "Model") {
+            // need to do properties after insertion to avoid infinite recursion
+            processModelProperties(context, newValue, type);
         }
     }
     else {
@@ -188,11 +230,11 @@ function getBodyType(program, route) {
     }
     return bodyModel;
 }
-function emitBodyParameter(program, httpOperation) {
+function emitBodyParameter(context, httpOperation) {
     var _a, _b, _c, _d, _e;
     const params = httpOperation.parameters;
     const body = params.body;
-    const base = emitParamBase(program, (_a = body.parameter) !== null && _a !== void 0 ? _a : body.type);
+    const base = emitParamBase(context.program, (_a = body.parameter) !== null && _a !== void 0 ? _a : body.type);
     let contentTypes = body.contentTypes;
     if (contentTypes.length === 0) {
         contentTypes = ["application/json"];
@@ -200,7 +242,9 @@ function emitBodyParameter(program, httpOperation) {
     if (contentTypes.length !== 1) {
         throw Error("Currently only one kind of content-type!");
     }
-    const type = getType(program, getBodyType(program, httpOperation));
+    const type = getType(context, getBodyType(context.program, httpOperation), {
+        disableEffectiveModel: true
+    });
     if (type.type === "model" && type.name === "") {
         type.name = capitalize(httpOperation.operation.name) + "Request";
     }
@@ -217,7 +261,7 @@ function emitBodyParameter(program, httpOperation) {
 }
 function emitParameter(context, parameter, implementation) {
     const base = emitParamBase(context.program, parameter.param);
-    let type = getType(context.program, parameter.param.type);
+    let type = getType(context, parameter.param.type);
     let clientDefaultValue = undefined;
     if (parameter.name.toLowerCase() === "content-type" &&
         type["type"] === "constant") {
@@ -249,23 +293,6 @@ function emitParameter(context, parameter, implementation) {
     }
     return { clientDefaultValue, ...base, ...paramMap };
 }
-function emitContentTypeParameter(bodyParameter, inOverload, inOverriden) {
-    return {
-        checkClientInput: false,
-        clientDefaultValue: bodyParameter.defaultContentType,
-        clientName: "content_type",
-        delimiter: null,
-        description: `Body parameter Content-Type. Known values are: ${bodyParameter.contentTypes}.`,
-        implementation: "Method",
-        inDocstring: true,
-        inOverload: inOverload,
-        inOverriden: inOverriden,
-        location: "header",
-        optional: true,
-        restApiName: "Content-Type",
-        type: { type: "string" }
-    };
-}
 function emitFlattenedParameter(bodyParameter, property) {
     return {
         checkClientInput: false,
@@ -303,34 +330,14 @@ function getConstantType(key) {
     simpleTypesMap.set(key, type);
     return type;
 }
-function emitAcceptParameter(_program, inOverload, inOverriden) {
-    return {
-        checkClientInput: false,
-        clientDefaultValue: "application/json",
-        clientName: "accept",
-        delimiter: null,
-        description: "Accept header.",
-        explode: false,
-        groupedBy: null,
-        implementation: "Method",
-        inDocstring: true,
-        inOverload: inOverload,
-        inOverriden: inOverriden,
-        location: "header",
-        optional: false,
-        restApiName: "Accept",
-        skipUrlEncoding: false,
-        type: getConstantType("application/json")
-    };
-}
-function emitResponseHeaders(program, headers) {
+function emitResponseHeaders(context, headers) {
     const retval = [];
     if (!headers) {
         return retval;
     }
     for (const [key, value] of Object.entries(headers)) {
         retval.push({
-            type: getType(program, value.type),
+            type: getType(context, value.type),
             restApiName: key
         });
     }
@@ -349,7 +356,7 @@ function isAzureCoreErrorType(t) {
     }
     return namespaces.length == 0;
 }
-function emitResponse(program, response, innerResponse) {
+function emitResponse(context, response, innerResponse) {
     var _a, _b;
     let type = undefined;
     if (((_a = innerResponse.body) === null || _a === void 0 ? void 0 : _a.type) &&
@@ -363,11 +370,11 @@ function emitResponse(program, response, innerResponse) {
         const originType = innerResponse.body.type;
         if (innerResponse.body.type.kind === "Model" &&
             candidate.find((e) => e === originType.name)) {
-            const modelType = getEffectiveSchemaType(program, originType);
-            type = getType(program, modelType);
+            const modelType = getEffectiveSchemaType(context.program, originType);
+            type = getType(context, modelType);
         }
         else {
-            type = getType(program, innerResponse.body.type);
+            type = getType(context, innerResponse.body.type);
         }
     }
     const statusCodes = [];
@@ -378,9 +385,9 @@ function emitResponse(program, response, innerResponse) {
         statusCodes.push(parseInt(response.statusCode));
     }
     return {
-        headers: emitResponseHeaders(program, innerResponse.headers),
+        headers: emitResponseHeaders(context, innerResponse.headers),
         statusCodes: statusCodes !== null && statusCodes !== void 0 ? statusCodes : [],
-        addedOn: getAddedOnVersion(program, response.type),
+        addedOn: getAddedOnVersion(context.program, response.type),
         discriminator: "basic",
         type: type
     };
@@ -449,15 +456,9 @@ function emitBasicOperation(context, operation, operationGroupName) {
     const responses = [];
     const exceptions = [];
     const isOverload = false;
-    const isOverriden = false;
     for (const response of httpOperation.responses) {
         for (const innerResponse of response.responses) {
-            const emittedResponse = emitResponse(context.program, response, innerResponse);
-            if (emittedResponse["type"] &&
-                parameters.filter((e) => e.restApiName.toLowerCase() === "accept")
-                    .length === 0) {
-                parameters.push(emitAcceptParameter(context.program, isOverload, isOverriden));
-            }
+            const emittedResponse = emitResponse(context, response, innerResponse);
             if (isErrorModel(context.program, response.type)) {
                 // * is valid status code in cadl but invalid for autorest.python
                 if (response.statusCode === "*") {
@@ -474,11 +475,7 @@ function emitBasicOperation(context, operation, operationGroupName) {
         bodyParameter = undefined;
     }
     else {
-        bodyParameter = emitBodyParameter(context.program, httpOperation);
-        if (parameters.filter((e) => e.restApiName.toLowerCase() === "content-type")
-            .length === 0) {
-            parameters.push(emitContentTypeParameter(bodyParameter, isOverload, isOverriden));
-        }
+        bodyParameter = emitBodyParameter(context, httpOperation);
         if (bodyParameter.type.type === "model" &&
             bodyParameter.type.base === "json") {
             bodyParameter["propertyToParameterName"] = {};
@@ -522,8 +519,8 @@ function isReadOnly(program, type) {
         return false;
     }
 }
-function emitProperty(program, property) {
-    var _a;
+function emitProperty(context, property) {
+    var _a, _b;
     let clientDefaultValue = undefined;
     const propertyDefaultKind = (_a = property.default) === null || _a === void 0 ? void 0 : _a.kind;
     if (property.default &&
@@ -532,15 +529,20 @@ function emitProperty(program, property) {
             propertyDefaultKind === "Boolean")) {
         clientDefaultValue = property.default.value;
     }
-    const restApiName = getProjectedName(program, property, "json");
+    // const [clientName, jsonName] = getPropertyNames(context, property);
+    const clientName = property.name;
+    const jsonName = (_b = getProjectedName(context.program, property, "json")) !== null && _b !== void 0 ? _b : property.name;
+    if (property.model) {
+        getType(context, property.model);
+    }
     return {
-        clientName: applyCasing(property.name, { casing: CASING }),
-        restApiName: restApiName !== null && restApiName !== void 0 ? restApiName : property.name,
-        type: getType(program, property.type),
+        clientName: applyCasing(clientName, { casing: CASING }),
+        restApiName: jsonName,
+        type: getType(context, property.type),
         optional: property.optional,
-        description: getDocStr(program, property),
-        addedOn: getAddedOnVersion(program, property),
-        readonly: isReadOnly(program, property) || isKey(program, property),
+        description: getDocStr(context.program, property),
+        addedOn: getAddedOnVersion(context.program, property),
+        readonly: isReadOnly(context.program, property) || isKey(context.program, property),
         clientDefaultValue: clientDefaultValue
     };
 }
@@ -563,23 +565,25 @@ function getName(program, type) {
         }
     }
 }
-function emitModel(program, type) {
+function emitModel(context, type) {
     // Now we know it's a defined model
     const properties = [];
     let baseModel = undefined;
     if (type.baseModel) {
-        baseModel = getType(program, type.baseModel);
+        baseModel = getType(context, type.baseModel);
     }
-    const effectiveName = getEffectiveSchemaType(program, type).name;
-    const modelName = effectiveName ? effectiveName : getName(program, type);
+    const effectiveName = getEffectiveSchemaType(context.program, type).name;
+    const modelName = effectiveName
+        ? effectiveName
+        : getName(context.program, type);
     return {
         type: "model",
         name: modelName,
-        description: getDocStr(program, type),
+        description: getDocStr(context.program, type),
         parents: baseModel ? [baseModel] : [],
         discriminatedSubtypes: {},
         properties: properties,
-        addedOn: getAddedOnVersion(program, type),
+        addedOn: getAddedOnVersion(context.program, type),
         snakeCaseName: modelName
             ? applyCasing(modelName, { casing: CASING })
             : modelName,
@@ -664,7 +668,7 @@ function emitCredentialUnion(cred_types) {
 function emitStdScalar(scalar) {
     switch (scalar.name) {
         case "bytes":
-            return { type: "byte-array", format: "byte" };
+            return { type: "Uint8Array", format: "byte" };
         case "int8":
         case "int16":
         case "int32":
@@ -751,27 +755,27 @@ function emitScalar(program, scalar) {
     }
     return applyIntrinsicDecorators(program, scalar, result);
 }
-function emitListOrDict(program, type) {
+function emitListOrDict(context, type) {
     if (type.indexer !== undefined) {
         if (!isNeverType(type.indexer.key)) {
             const name = type.indexer.key.name;
             if (name === "string") {
                 return {
                     type: "dict",
-                    elementType: getType(program, type.indexer.value)
+                    elementType: getType(context, type.indexer.value)
                 };
             }
             else if (name === "integer") {
                 return {
                     type: "list",
-                    elementType: getType(program, type.indexer.value)
+                    elementType: getType(context, type.indexer.value)
                 };
             }
         }
     }
     return undefined;
 }
-function mapCadlType(program, type) {
+function mapCadlType(context, type) {
     switch (type.kind) {
         case "Number":
             return constantType(type.value, intOrFloat(type.value));
@@ -780,82 +784,95 @@ function mapCadlType(program, type) {
         case "Boolean":
             return constantType(type.value, "boolean");
         case "Model":
-            return emitListOrDict(program, type);
+            return emitListOrDict(context, type);
     }
 }
 function capitalize(name) {
     return name[0].toUpperCase() + name.slice(1);
 }
-function emitUnion(program, type) {
-    const nonNullOptions = [...type.variants.values()]
-        .map((x) => x.type)
-        .filter((t) => !isNullType(t));
-    const notLiteral = (t) => ["Boolean", "Number", "String"].indexOf(t.kind) < 0;
-    if (nonNullOptions.length > 1) {
-        if (nonNullOptions.every(notLiteral)) {
-            // Generate as CombinedType if non of the options is Literal.
-            const unionName = `MyCombinedType`;
-            return {
-                name: unionName,
-                snakeCaseName: applyCasing(unionName, { casing: CASING }),
-                description: `Type of ${unionName}`,
-                isPublic: false,
-                type: "combined",
-                types: nonNullOptions.map((x) => emitType(program, x)),
-                xmlMetadata: {}
-            };
-        }
-        else if (nonNullOptions.some(notLiteral)) {
-            // Can't generate if this union is a mixed up of literals and sub-types
-            throw Error(`Can't do union for ${JSON.stringify(nonNullOptions)}`);
-        }
+function emitUnion(context, type) {
+    const sdkType = getSdkUnion(context, type);
+    if (sdkType === undefined) {
+        throw Error("Should not have an empty union");
     }
-    // Geneate Union of Literals as Python Enum
-    const values = [];
-    for (const option of nonNullOptions) {
-        const value = emitType(program, option)["value"];
-        values.push({
-            description: "",
-            name: applyCasing(value, { casing: CASING }).toUpperCase(),
-            value: value
-        });
+    if (sdkType.kind === "union") {
+        const unionName = type.name;
+        return {
+            nullable: sdkType.nullable,
+            name: unionName,
+            description: `Type of ${unionName}`,
+            internal: true,
+            type: "combined",
+            types: sdkType.values.map((x) => getType(context, x.__raw)),
+            xmlMetadata: {}
+        };
     }
-    let enumName = "MyEnum";
-    if (type.node &&
-        type.node.parent &&
-        [SyntaxKind.ModelStatement, SyntaxKind.ModelProperty].includes(type.node.parent.kind)) {
-        if (type.node.parent.kind === SyntaxKind.ModelStatement) {
-            enumName = capitalize(type.node.parent.id.sv);
-        }
-        else if (type.node.parent.kind === SyntaxKind.ModelProperty) {
-            const parent = type.node.parent;
-            if (parent.id.sv) {
-                enumName = capitalize(parent.id.sv) + "Type";
-            }
-        }
+    else if (sdkType.kind === "enum") {
+        return {
+            name: sdkType.name,
+            nullable: sdkType.nullable,
+            description: sdkType.doc || `Type of ${sdkType.name}`,
+            internal: true,
+            type: sdkType.kind,
+            valueType: emitSimpleType(context, sdkType.valueType),
+            values: sdkType.values.map((x) => emitEnumMember(x)),
+            isFixed: sdkType.isFixed === false ? false : true,
+            xmlMetadata: {}
+        };
+    }
+    else {
+        return { nullable: sdkType.nullable, ...emitType(context, sdkType.__raw) };
     }
+}
+function emitEnumMember(type) {
     return {
-        name: enumName,
-        snakeCaseName: applyCasing(enumName, { casing: CASING }),
-        description: `Type of ${enumName}`,
-        isPublic: false,
-        type: "enum",
-        valueType: emitType(program, nonNullOptions[0])["valueType"],
-        values: values,
-        xmlMetadata: {}
+        name: enumName(type.name),
+        value: type.value,
+        description: type.doc
+    };
+}
+function emitSimpleType(context, type) {
+    let sdkType;
+    if (type.kind === "Scalar" || type.kind === "Intrinsic") {
+        sdkType = getSdkSimpleType(context, type);
+    }
+    else {
+        sdkType = type;
+    }
+    const extraInformation = {};
+    if (sdkType.kind === "string") {
+        extraInformation["pattern"] = sdkType.pattern;
+        extraInformation["minLength"] = sdkType.minLength;
+        extraInformation["maxLength"] = sdkType.maxLength;
+    }
+    else if (sdkType.kind === "int32" ||
+        sdkType.kind === "int64" ||
+        sdkType.kind === "float32" ||
+        sdkType.kind === "float64") {
+        extraInformation["minValue"] = sdkType.minValue;
+        extraInformation["maxValue"] = sdkType.maxValue;
+    }
+    return {
+        nullable: sdkType.nullable,
+        type: "number",
+        doc: sdkType.doc,
+        apiVersions: sdkType.apiVersions,
+        sdkDefaultValue: sdkType.sdkDefaultValue,
+        format: sdkType.format,
+        ...extraInformation
     };
 }
-function emitType(program, type) {
+function emitType(context, type) {
     if (type.kind === "Credential") {
         return emitCredential(type.scheme);
     }
     if (type.kind === "CredentialTypeUnion") {
         return emitCredentialUnion(type);
     }
-    const builtinType = mapCadlType(program, type);
+    const builtinType = mapCadlType(context, type);
     if (builtinType !== undefined) {
         // add in description elements for types derived from primitive types (SecureString, etc.)
-        const doc = getDoc(program, type);
+        const doc = getDoc(context.program, type);
         if (doc) {
             builtinType.description = doc;
         }
@@ -863,17 +880,17 @@ function emitType(program, type) {
     }
     switch (type.kind) {
         case "Intrinsic":
-            return { type: "any" };
+            return { type: type.name };
         case "Model":
-            return emitModel(program, type);
+            return emitModel(context, type);
         case "Scalar":
-            return emitScalar(program, type);
+            return emitScalar(context.program, type);
         case "Union":
-            return emitUnion(program, type);
+            return emitUnion(context, type);
         case "UnionVariant":
             return {};
         case "Enum":
-            return emitEnum(program, type);
+            return emitEnum(context.program, type);
         default:
             throw Error(`Not supported ${type.kind}`);
     }
@@ -964,8 +981,8 @@ function emitServerParams(context, namespace) {
         ];
     }
 }
-function emitCredentialParam(program, namespace) {
-    const auth = getAuthentication(program, namespace);
+function emitCredentialParam(context, namespace) {
+    const auth = getAuthentication(context.program, namespace);
     if (auth) {
         const credential_types = [];
         for (const option of auth.options) {
@@ -989,7 +1006,7 @@ function emitCredentialParam(program, namespace) {
                 };
             }
             return {
-                type: getType(program, type),
+                type: getType(context, type),
                 optional: false,
                 description: "Credential needed for the client to connect to Azure.",
                 clientName: "credential",
@@ -1005,7 +1022,7 @@ function emitCredentialParam(program, namespace) {
 }
 function emitGlobalParameters(context, namespace) {
     const clientParameters = emitServerParams(context, namespace);
-    const credentialParam = emitCredentialParam(context.program, namespace);
+    const credentialParam = emitCredentialParam(context, namespace);
     if (credentialParam) {
         clientParameters.push(credentialParam);
     }
@@ -1092,6 +1109,10 @@ export function emitCodeModel(context, options = { casing: "snake" }) {
         clients: [],
         types: []
     };
+    const allModels = getAllModels(dpgContext);
+    for (const model of allModels) {
+        getType(dpgContext, model);
+    }
     for (const namespace of getNamespaces(dpgContext)) {
         if (namespace === clientNamespaceString) {
             codeModel.clients = emitClients(dpgContext, namespace);
@@ -1100,9 +1121,9 @@ export function emitCodeModel(context, options = { casing: "snake" }) {
             codeModel["subnamespaceToClients"][namespace] = emitClients(dpgContext, namespace);
         }
     }
-    codeModel.types = [
-        ...[...typesMap.values()].filter((t) => t.name !== "object"),
+    codeModel["types"] = [
         { type: "string" },
+        ...typesMap.values(),
         ...simpleTypesMap.values()
     ];
     return codeModel;