@azure-tools/typespec-go 0.8.3 → 0.8.5

package/dist/typespec-go/src/tcgcadapter/clients.js

@@ -91,13 +91,8 @@ export class clientAdapter {
             AuthTypes[AuthTypes["Default"] = 0] = "Default";
             AuthTypes[AuthTypes["NoAuth"] = 1] = "NoAuth";
             AuthTypes[AuthTypes["WithAuth"] = 2] = "WithAuth";
-            AuthTypes[AuthTypes["OmitAuth"] = 4] = "OmitAuth";
         })(AuthTypes || (AuthTypes = {}));
-        // we skip generating client constructors when emitting into
-        // an existing module. this is because the constructor(s) require
-        // the module name and version info, and we can't make any
-        // assumptions about the names/location.
-        let authType = (this.ta.codeModel.options.omitConstructors || this.ta.codeModel.options.containingModule) ? AuthTypes.OmitAuth : AuthTypes.Default;
+        let authType = AuthTypes.Default;
         if (!this.ta.codeModel.options.omitConstructors && this.ta.codeModel.options.containingModule) {
             // emit a diagnostic indicating that no ctors will be emitted due to containing-module.
             this.ctx.program.reportDiagnostic({
@@ -107,6 +102,15 @@ export class clientAdapter {
                 target: sdkClient.__raw.type ?? NoTarget,
             });
         }
+        if ((this.ta.codeModel.options.omitConstructors || this.ta.codeModel.options.containingModule) && this.ta.codeModel.options.generateExamples) {
+            // emit a diagnostic indicating that no ctors will be emitted due to containing-module.
+            this.ctx.program.reportDiagnostic({
+                code: 'UnsupportedConfiguration',
+                severity: 'warning',
+                message: 'cannot emit examples when containing-module or omit-constructors is set',
+                target: sdkClient.__raw.type ?? NoTarget,
+            });
+        }
         /**
          * processes a credendial, potentially adding its supporting client constructor
          *
@@ -143,16 +147,23 @@ export class clientAdapter {
         }
         // anything other than public means non-instantiable client
         if (sdkClient.clientInitialization.initializedBy & tcgc.InitializedByFlags.Individually) {
-            goClient.instance = new go.Constructable(go.newClientOptions(this.ta.codeModel.type, clientName));
+            let constructable;
+            // we skip generating client constructors when emitting into
+            // an existing module. this is because the constructor(s) require
+            // the module name and version info, and we can't make any
+            // assumptions about the names/location.
+            if (!this.ta.codeModel.options.omitConstructors && !this.ta.codeModel.options.containingModule) {
+                constructable = new go.Constructable(go.newClientOptions(this.ta.codeModel.type, clientName));
+            }
             for (const param of sdkClient.clientInitialization.parameters) {
                 switch (param.kind) {
                     case 'credential':
-                        if (authType === AuthTypes.OmitAuth) {
+                        if (!constructable) {
                             continue;
                         }
                         switch (param.type.kind) {
                             case 'credential':
-                                authType |= processCredential(goClient, goClient.instance, param.type.scheme);
+                                authType |= processCredential(goClient, constructable, param.type.scheme);
                                 break;
                             case 'union': {
                                 const variantKinds = new Array();
@@ -161,7 +172,7 @@ export class clientAdapter {
                                     // emit the support credential kinds and skip any unsupported ones.
                                     // this prevents emitting the WithNoCredential constructor in cases
                                     // where it might not actually be supported.
-                                    authType |= processCredential(goClient, goClient.instance, variantType.scheme);
+                                    authType |= processCredential(goClient, constructable, variantType.scheme);
                                 }
                                 // no supported credential types were specified
                                 if (authType === AuthTypes.Default) {
@@ -170,7 +181,7 @@ export class clientAdapter {
                                 continue;
                             }
                         }
-                        continue;
+                        break;
                     case 'endpoint': {
                         if (this.ta.codeModel.type === 'azure-arm') {
                             // for ARM, the endpoint is handled via the azcore/arm.Client
@@ -201,23 +212,36 @@ export class clientAdapter {
                                 adaptedParam.docs.summary = param.summary;
                                 adaptedParam.docs.description = param.doc;
                                 goClient.parameters.push(adaptedParam);
-                                // if the server's URL is *only* the endpoint parameter then we're done.
-                                // this is the param.type.kind === 'endpoint' case.
-                                if (endpointType.serverUrl === `{${templateArg.serializedName}}`) {
-                                    break;
+                                if (constructable) {
+                                    constructable.endpoint = new go.ClientEndpoint(adaptedParam);
+                                    // if the server's URL is *only* the endpoint parameter then we're done.
+                                    // this is the param.type.kind === 'endpoint' case.
+                                    if (endpointType.serverUrl === `{${templateArg.serializedName}}`) {
+                                        break;
+                                    }
+                                    // there's either a suffix on the endpoint param, more template arguments, or both.
+                                    // either way we need to create supplemental info on the constructable.
+                                    // strip off the first segment which corresponds to the endpoint param as it's not needed.
+                                    const serverUrl = endpointType.serverUrl.replace(`{${templateArg.serializedName}}/`, '');
+                                    constructable.endpoint.supplemental = new go.SupplementalEndpoint(serverUrl);
                                 }
-                                // there's either a suffix on the endpoint param, more template arguments, or both.
-                                // either way we need to create supplemental info on the constructable.
-                                // strip off the first segment which corresponds to the endpoint param as it's not needed.
-                                const serverUrl = endpointType.serverUrl.replace(`{${templateArg.serializedName}}/`, '');
-                                goClient.instance.endpoint = new go.SupplementalEndpoint(serverUrl);
                                 continue;
                             }
-                            const adaptedParam = this.adaptURIParam(templateArg, false);
-                            adaptedParam.docs.summary = templateArg.summary;
-                            adaptedParam.docs.description = templateArg.doc;
-                            adaptedParam.isApiVersion = templateArg.isApiVersionParam;
-                            goClient.instance.endpoint?.parameters.push(adaptedParam);
+                            if (constructable) {
+                                const adaptedParam = this.adaptURIParam(templateArg, false);
+                                adaptedParam.docs.summary = templateArg.summary;
+                                adaptedParam.docs.description = templateArg.doc;
+                                adaptedParam.isApiVersion = templateArg.isApiVersionParam;
+                                constructable.endpoint?.supplemental?.parameters.push(adaptedParam);
+                                if (!go.isRequiredParameter(adaptedParam.style)) {
+                                    if (constructable.options.kind === 'clientOptions') {
+                                        constructable.options.parameters.push(adaptedParam);
+                                    }
+                                    else {
+                                        throw new AdapterError('UnsupportedTsp', 'optional client parameters for ARM is not supported', templateArg.__raw?.node ?? NoTarget);
+                                    }
+                                }
+                            }
                         }
                         break;
                     }
@@ -236,25 +260,22 @@ export class clientAdapter {
                         continue;
                 }
             }
-            // if no authentication type was specified, or the noAuth scheme was
-            // explicitly specified, then include the WithNoCredential constructor
-            if (authType === AuthTypes.Default || (authType & AuthTypes.NoAuth) === AuthTypes.NoAuth) {
-                goClient.instance.constructors.push(new go.Constructor(`New${clientName}WithNoCredential`, new go.NoAuthentication()));
-            }
-            // propagate optional params to the optional params group
-            for (const param of goClient.parameters) {
-                if (!go.isRequiredParameter(param.style) && !go.isLiteralParameter(param.style) && goClient.instance.options.kind === 'clientOptions') {
-                    goClient.instance.options.params.push(param);
+            if (constructable) {
+                goClient.instance = constructable;
+                // if no authentication type was specified, or the noAuth scheme was
+                // explicitly specified, then include the WithNoCredential constructor
+                if (authType === AuthTypes.Default || (authType & AuthTypes.NoAuth) === AuthTypes.NoAuth) {
+                    goClient.instance.constructors.push(new go.Constructor(`New${clientName}WithNoCredential`));
+                }
+                // propagate ctor params to all client ctors
+                for (const constructor of goClient.instance.constructors) {
+                    constructor.parameters.push(...goClient.parameters);
                 }
-            }
-            // if we created constructors, propagate the persisted client params to them
-            for (const constructor of goClient.instance.constructors) {
-                constructor.parameters = goClient.parameters;
             }
         }
         else if (parent) {
             // this is a sub-client. it will share the client/host params of the parent.
-            // NOTE: we must propagate parant params before a potential recursive call
+            // NOTE: we must propagate parent params before a potential recursive call
             // to create a child client that will need to inherit our client params.
             if (parent.instance?.kind === 'templatedHost') {
                 goClient.instance = parent.instance;
@@ -305,7 +326,9 @@ export class clientAdapter {
         else if (cred.flows[0].scopes.length > 1) {
             throw new AdapterError('InternalError', `too many scopes defined for credential type ${cred.type}`, cred.model);
         }
-        return new go.Constructor(`New${goClient.name}`, new go.TokenAuthentication(cred.flows[0].scopes.map(each => each.value)));
+        const ctor = new go.Constructor(`New${goClient.name}`);
+        ctor.parameters.push(new go.ClientCredentialParameter('credential', new go.TokenCredential(cred.flows[0].scopes.map(each => each.value))));
+        return ctor;
     }
     /**
      * creates a new Go URI parameter from the specified tcgc path parameter
@@ -324,10 +347,13 @@ export class clientAdapter {
         }
         if (go.isURIParameterType(paramType)) {
             const style = forceRequired ? 'required' : this.adaptParameterStyle(sdkParam);
-            // TODO: follow up with tcgc if serializedName should actually be optional
-            const uriParam = new go.URIParameter(sdkParam.name, sdkParam.serializedName ? sdkParam.serializedName : sdkParam.name, paramType, style, isTypePassedByValue(sdkParam.type) || !sdkParam.optional, 'client');
+            if (this.ta.codeModel.type === 'azure-arm' && !go.isRequiredParameter(style)) {
+                throw new AdapterError('UnsupportedTsp', 'optional client parameters for ARM is not supported', sdkParam.__raw?.node ?? NoTarget);
+            }
+            const uriParam = new go.URIParameter(sdkParam.name, sdkParam.serializedName, paramType, style, isTypePassedByValue(sdkParam.type) || !sdkParam.optional, 'client');
             uriParam.docs.summary = sdkParam.summary;
             uriParam.docs.description = sdkParam.doc;
+            uriParam.isApiVersion = sdkParam.isApiVersionParam;
             return uriParam;
         }
         throw new AdapterError('UnsupportedTsp', `unsupported URI parameter type ${paramType.kind}`, sdkParam.__raw?.node ?? NoTarget);
@@ -369,6 +395,18 @@ export class clientAdapter {
                 throw new AdapterError('UnsupportedTsp', `paging with re-injected parameters is not supported`, sdkMethod.__raw?.node ?? NoTarget);
             }
             method = new go.PageableMethod(methodName, goClient, sdkMethod.operation.path, sdkMethod.operation.verb, statusCodes, naming);
+            if (sdkMethod.pagingMetadata.nextLinkVerb) {
+                switch (sdkMethod.pagingMetadata.nextLinkVerb) {
+                    case 'GET':
+                        // we default to GET in the ctor for PageableMethod
+                        break;
+                    case 'POST':
+                        method.nextLinkVerb = 'post';
+                        break;
+                    default:
+                        sdkMethod.pagingMetadata.nextLinkVerb;
+                }
+            }
             if (sdkMethod.pagingMetadata.nextLinkSegments) {
                 method.nextLinkName = capitalize(sdkMethod.pagingMetadata.nextLinkSegments.map((segment) => {
                     if (segment.kind === 'property') {
@@ -518,7 +556,9 @@ export class clientAdapter {
                 opParam.correspondingMethodParams[0].optional = false;
             }
             let adaptedParam;
-            if (opParam.kind === 'body' && opParam.type.kind === 'model' && opParam.type.kind !== param.type.kind) {
+            // for the @bodyRoot decorator opParam.type !== param.type which is obviously not a
+            // spread parameter. we also need to check the usage flag to disambiguate these cases.
+            if (opParam.kind === 'body' && opParam.type.kind === 'model' && opParam.type !== param.type && (opParam.type.usage & tcgc.UsageFlags.Spread)) {
                 const paramStyle = this.adaptParameterStyle(param);
                 const paramName = getEscapedReservedName(ensureNameCase(param.name, paramStyle === 'required'), 'Param');
                 // if the param is required then it's always passed by value
@@ -609,7 +649,17 @@ export class clientAdapter {
                 if (!method.receiver.type.parameters.find((v) => {
                     return v.name === adaptedParam.name;
                 })) {
+                    if (this.ta.codeModel.type === 'azure-arm' && adaptedParam.style !== 'literal' && adaptedParam.style !== 'required') {
+                        throw new AdapterError('UnsupportedTsp', 'optional client parameters for ARM is not supported', opParam.__raw?.node ?? NoTarget);
+                    }
                     method.receiver.type.parameters.push(adaptedParam);
+                    if (method.receiver.type.instance?.kind === 'constructable') {
+                        // if this is an instantiable client then also add
+                        // the client parameter to all constructors
+                        for (const ctor of method.receiver.type.instance.constructors) {
+                            ctor.parameters.push(adaptedParam);
+                        }
+                    }
                 }
             }
         }
@@ -1037,22 +1087,33 @@ export class clientAdapter {
     adaptHttpOperationExamples(sdkMethod, method, paramMapping) {
         if (sdkMethod.operation.examples && sdkMethod.access !== 'internal') {
             for (const example of sdkMethod.operation.examples) {
-                const goExample = new go.MethodExample(example.name, { summary: example.doc }, example.filePath);
-                for (const param of example.parameters) {
-                    if (param.parameter.isApiVersionParam && param.parameter.clientDefaultValue) {
-                        // skip the api-version param as it's not a formal parameter
-                        continue;
-                    }
-                    const goParams = paramMapping.get(param.parameter);
-                    if (!goParams) {
-                        throw new AdapterError('InternalError', `can not find go param for example param ${param.parameter.name}`, NoTarget);
-                    }
-                    if (goParams.length > 1) {
-                        // spread case
-                        for (const goParam of goParams) {
-                            const propertyValue = param.value.value[goParam.serializedName];
-                            const paramExample = new go.ParameterExample(goParam, this.adaptExampleType(propertyValue, goParam?.type));
-                            if (goParam.group) {
+                try {
+                    const goExample = new go.MethodExample(example.name, { summary: example.doc }, example.filePath);
+                    for (const param of example.parameters) {
+                        if (param.parameter.isApiVersionParam && param.parameter.clientDefaultValue) {
+                            // skip the api-version param as it's not a formal parameter
+                            continue;
+                        }
+                        const goParams = paramMapping.get(param.parameter);
+                        if (!goParams) {
+                            throw new AdapterError('InternalError', `can not find go param for example param ${param.parameter.name}`, NoTarget);
+                        }
+                        if (goParams.length > 1) {
+                            // spread case
+                            for (const goParam of goParams) {
+                                const propertyValue = param.value.value[goParam.serializedName];
+                                const paramExample = new go.ParameterExample(goParam, this.adaptExampleType(propertyValue, goParam?.type));
+                                if (goParam.group) {
+                                    goExample.optionalParamsGroup.push(paramExample);
+                                }
+                                else {
+                                    goExample.parameters.push(paramExample);
+                                }
+                            }
+                        }
+                        else {
+                            const paramExample = new go.ParameterExample(goParams[0], this.adaptExampleType(param.value, goParams[0]?.type));
+                            if (goParams[0]?.group) {
                                 goExample.optionalParamsGroup.push(paramExample);
                             }
                             else {
@@ -1060,51 +1121,49 @@ export class clientAdapter {
                             }
                         }
                     }
-                    else {
-                        const paramExample = new go.ParameterExample(goParams[0], this.adaptExampleType(param.value, goParams[0]?.type));
-                        if (goParams[0]?.group) {
-                            goExample.optionalParamsGroup.push(paramExample);
+                    // only handle 200 response
+                    const response = example.responses.find((v) => { return v.statusCode === 200; });
+                    if (response) {
+                        goExample.responseEnvelope = new go.ResponseEnvelopeExample(method.returns);
+                        for (const header of response.headers) {
+                            const goHeader = method.returns.headers.find(h => h.headerName === header.header.serializedName);
+                            if (!goHeader) {
+                                throw new AdapterError('InternalError', `can not find go header for example header ${header.header.serializedName}`, NoTarget);
+                            }
+                            goExample.responseEnvelope.headers.push(new go.ResponseHeaderExample(goHeader, this.adaptExampleType(header.value, goHeader.type)));
                         }
-                        else {
-                            goExample.parameters.push(paramExample);
+                        // there are some problems with LROs at present which can cause the result
+                        // to be undefined even though the operation returns a response.
+                        // TODO: https://github.com/Azure/typespec-azure/issues/1688
+                        if (response.bodyValue && method.returns.result) {
+                            switch (method.returns.result.kind) {
+                                case 'anyResult':
+                                    goExample.responseEnvelope.result = this.adaptExampleType(response.bodyValue, new go.Any());
+                                    break;
+                                case 'binaryResult':
+                                    goExample.responseEnvelope.result = this.adaptExampleType(response.bodyValue, new go.Scalar('byte', false));
+                                    break;
+                                case 'modelResult':
+                                    goExample.responseEnvelope.result = this.adaptExampleType(response.bodyValue, method.returns.result.modelType);
+                                    break;
+                                case 'monomorphicResult':
+                                    goExample.responseEnvelope.result = this.adaptExampleType(response.bodyValue, method.returns.result.monomorphicType);
+                                    break;
+                                case 'polymorphicResult':
+                                    goExample.responseEnvelope.result = this.adaptExampleType(response.bodyValue, method.returns.result.interface);
+                                    break;
+                            }
                         }
                     }
+                    method.examples.push(goExample);
                 }
-                // only handle 200 response
-                const response = example.responses.find((v) => { return v.statusCode === 200; });
-                if (response) {
-                    goExample.responseEnvelope = new go.ResponseEnvelopeExample(method.returns);
-                    for (const header of response.headers) {
-                        const goHeader = method.returns.headers.find(h => h.headerName === header.header.serializedName);
-                        if (!goHeader) {
-                            throw new AdapterError('InternalError', `can not find go header for example header ${header.header.serializedName}`, NoTarget);
-                        }
-                        goExample.responseEnvelope.headers.push(new go.ResponseHeaderExample(goHeader, this.adaptExampleType(header.value, goHeader.type)));
-                    }
-                    // there are some problems with LROs at present which can cause the result
-                    // to be undefined even though the operation returns a response.
-                    // TODO: https://github.com/Azure/typespec-azure/issues/1688
-                    if (response.bodyValue && method.returns.result) {
-                        switch (method.returns.result.kind) {
-                            case 'anyResult':
-                                goExample.responseEnvelope.result = this.adaptExampleType(response.bodyValue, new go.Any());
-                                break;
-                            case 'binaryResult':
-                                goExample.responseEnvelope.result = this.adaptExampleType(response.bodyValue, new go.Scalar('byte', false));
-                                break;
-                            case 'modelResult':
-                                goExample.responseEnvelope.result = this.adaptExampleType(response.bodyValue, method.returns.result.modelType);
-                                break;
-                            case 'monomorphicResult':
-                                goExample.responseEnvelope.result = this.adaptExampleType(response.bodyValue, method.returns.result.monomorphicType);
-                                break;
-                            case 'polymorphicResult':
-                                goExample.responseEnvelope.result = this.adaptExampleType(response.bodyValue, method.returns.result.interface);
-                                break;
-                        }
+                catch (error) {
+                    // Only added try-catch block to output error message and example file path
+                    if (error instanceof AdapterError) {
+                        throw new AdapterError(error.code, `${error.message} (example file: '${example.filePath}')`, error.target);
                     }
+                    throw error;
                 }
-                method.examples.push(goExample);
             }
         }
     }
@@ -1185,17 +1244,23 @@ export class clientAdapter {
                     const ret = new go.StructExample(concreteType);
                     for (const [k, v] of Object.entries(exampleType.value)) {
                         const field = concreteType.fields.find(f => f.serializedName === k);
+                        if (!field) {
+                            throw new AdapterError('InternalError', `field with serializedName '${k}' not found in model '${concreteType.name}'.`, NoTarget);
+                        }
                         ret.value[field.name] = this.adaptExampleType(v, field.type);
                     }
                     if (exampleType.additionalPropertiesValue) {
                         ret.additionalProperties = {};
                         for (const [k, v] of Object.entries(exampleType.additionalPropertiesValue)) {
                             const filed = concreteType.fields.find(f => f.annotations.isAdditionalProperties);
+                            if (!filed) {
+                                throw new AdapterError('InternalError', `additional properties field not found in model '${concreteType.name}'.`, NoTarget);
+                            }
                             if (filed.type.kind === 'map') {
                                 ret.additionalProperties[k] = this.adaptExampleType(v, filed.type.valueType);
                             }
                             else {
-                                throw new AdapterError('InternalError', `additional properties field type should be map type`, NoTarget);
+                                throw new AdapterError('InternalError', `additional properties field type should be map type, but got '${filed.type.kind}' in model '${concreteType.name}'`, NoTarget);
                             }
                         }
                     }