@microsoft/m365-spec-parser 0.1.1-alpha.a277dba4e.0 → 0.1.1-alpha.b54a7ba8f.0

package/dist/index.esm2017.mjs

@@ -29,6 +29,21 @@ var ErrorType;
     ErrorType["GenerateFailed"] = "generate-failed";
     ErrorType["ValidateFailed"] = "validate-failed";
     ErrorType["GetSpecFailed"] = "get-spec-failed";
+    ErrorType["AuthTypeIsNotSupported"] = "auth-type-is-not-supported";
+    ErrorType["MissingOperationId"] = "missing-operation-id";
+    ErrorType["PostBodyContainMultipleMediaTypes"] = "post-body-contain-multiple-media-types";
+    ErrorType["ResponseContainMultipleMediaTypes"] = "response-contain-multiple-media-types";
+    ErrorType["ResponseJsonIsEmpty"] = "response-json-is-empty";
+    ErrorType["PostBodySchemaIsNotJson"] = "post-body-schema-is-not-json";
+    ErrorType["PostBodyContainsRequiredUnsupportedSchema"] = "post-body-contains-required-unsupported-schema";
+    ErrorType["ParamsContainRequiredUnsupportedSchema"] = "params-contain-required-unsupported-schema";
+    ErrorType["ParamsContainsNestedObject"] = "params-contains-nested-object";
+    ErrorType["RequestBodyContainsNestedObject"] = "request-body-contains-nested-object";
+    ErrorType["ExceededRequiredParamsLimit"] = "exceeded-required-params-limit";
+    ErrorType["NoParameter"] = "no-parameter";
+    ErrorType["NoAPIInfo"] = "no-api-info";
+    ErrorType["MethodNotAllowed"] = "method-not-allowed";
+    ErrorType["UrlPathNotExist"] = "url-path-not-exist";
     ErrorType["Cancelled"] = "cancelled";
     ErrorType["Unknown"] = "unknown";
 })(ErrorType || (ErrorType = {}));
@@ -179,6 +194,7 @@ class Utils {
             requiredNum: 0,
             optionalNum: 0,
             isValid: true,
+            reason: [],
         };
         if (!paramObject) {
             return paramResult;
@@ -188,6 +204,7 @@ class Utils {
             const schema = param.schema;
             if (isCopilot && this.hasNestedObjectInSchema(schema)) {
                 paramResult.isValid = false;
+                paramResult.reason.push(ErrorType.ParamsContainsNestedObject);
                 continue;
             }
             const isRequiredWithoutDefault = param.required && schema.default === undefined;
@@ -203,6 +220,7 @@ class Utils {
             if (param.in === "header" || param.in === "cookie") {
                 if (isRequiredWithoutDefault) {
                     paramResult.isValid = false;
+                    paramResult.reason.push(ErrorType.ParamsContainRequiredUnsupportedSchema);
                 }
                 continue;
             }
@@ -212,6 +230,7 @@ class Utils {
                 schema.type !== "integer") {
                 if (isRequiredWithoutDefault) {
                     paramResult.isValid = false;
+                    paramResult.reason.push(ErrorType.ParamsContainRequiredUnsupportedSchema);
                 }
                 continue;
             }
@@ -232,6 +251,7 @@ class Utils {
             requiredNum: 0,
             optionalNum: 0,
             isValid: true,
+            reason: [],
         };
         if (Object.keys(schema).length === 0) {
             return paramResult;
@@ -239,6 +259,7 @@ class Utils {
         const isRequiredWithoutDefault = isRequired && schema.default === undefined;
         if (isCopilot && this.hasNestedObjectInSchema(schema)) {
             paramResult.isValid = false;
+            paramResult.reason = [ErrorType.RequestBodyContainsNestedObject];
             return paramResult;
         }
         if (schema.type === "string" ||
@@ -263,11 +284,13 @@ class Utils {
                 paramResult.requiredNum += result.requiredNum;
                 paramResult.optionalNum += result.optionalNum;
                 paramResult.isValid = paramResult.isValid && result.isValid;
+                paramResult.reason.push(...result.reason);
             }
         }
         else {
             if (isRequiredWithoutDefault && !isCopilot) {
                 paramResult.isValid = false;
+                paramResult.reason.push(ErrorType.PostBodyContainsRequiredUnsupportedSchema);
             }
         }
         return paramResult;
@@ -291,103 +314,123 @@ class Utils {
      */
     static isSupportedApi(method, path, spec, options) {
         var _a;
-        const pathObj = spec.paths[path];
+        const result = { isValid: true, reason: [] };
         method = method.toLocaleLowerCase();
-        if (pathObj) {
-            if (((_a = options.allowMethods) === null || _a === void 0 ? void 0 : _a.includes(method)) && pathObj[method]) {
-                const securities = pathObj[method].security;
-                const isTeamsAi = options.projectType === ProjectType.TeamsAi;
-                const isCopilot = options.projectType === ProjectType.Copilot;
-                // Teams AI project doesn't care about auth, it will use authProvider for user to implement
-                if (!isTeamsAi) {
-                    const authArray = Utils.getAuthArray(securities, spec);
-                    if (!Utils.isSupportedAuth(authArray, options)) {
-                        return false;
-                    }
-                }
-                const operationObject = pathObj[method];
-                if (!options.allowMissingId && !operationObject.operationId) {
-                    return false;
-                }
-                const paramObject = operationObject.parameters;
-                const requestBody = operationObject.requestBody;
-                const requestJsonBody = requestBody === null || requestBody === void 0 ? void 0 : requestBody.content["application/json"];
-                if (!isTeamsAi && Utils.containMultipleMediaTypes(requestBody)) {
-                    return false;
-                }
-                const responseJson = Utils.getResponseJson(operationObject, isTeamsAi);
-                if (Object.keys(responseJson).length === 0) {
-                    return false;
-                }
-                // Teams AI project doesn't care about request parameters/body
-                if (isTeamsAi) {
-                    return true;
-                }
-                let requestBodyParamResult = {
-                    requiredNum: 0,
-                    optionalNum: 0,
-                    isValid: true,
-                };
-                if (requestJsonBody) {
-                    const requestBodySchema = requestJsonBody.schema;
-                    if (isCopilot && requestBodySchema.type !== "object") {
-                        return false;
-                    }
-                    requestBodyParamResult = Utils.checkPostBody(requestBodySchema, requestBody.required, isCopilot);
-                }
-                if (!requestBodyParamResult.isValid) {
-                    return false;
-                }
-                const paramResult = Utils.checkParameters(paramObject, isCopilot);
-                if (!paramResult.isValid) {
-                    return false;
+        if (options.allowMethods && !options.allowMethods.includes(method)) {
+            result.isValid = false;
+            result.reason.push(ErrorType.MethodNotAllowed);
+            return result;
+        }
+        const pathObj = spec.paths[path];
+        if (!pathObj || !pathObj[method]) {
+            result.isValid = false;
+            result.reason.push(ErrorType.UrlPathNotExist);
+            return result;
+        }
+        const securities = pathObj[method].security;
+        const isTeamsAi = options.projectType === ProjectType.TeamsAi;
+        const isCopilot = options.projectType === ProjectType.Copilot;
+        // Teams AI project doesn't care about auth, it will use authProvider for user to implement
+        if (!isTeamsAi) {
+            const authArray = Utils.getAuthArray(securities, spec);
+            const authCheckResult = Utils.isSupportedAuth(authArray, options);
+            if (!authCheckResult.isValid) {
+                result.reason.push(...authCheckResult.reason);
+            }
+        }
+        const operationObject = pathObj[method];
+        if (!options.allowMissingId && !operationObject.operationId) {
+            result.reason.push(ErrorType.MissingOperationId);
+        }
+        const rootServer = spec.servers && spec.servers[0];
+        const methodServer = spec.paths[path].servers && ((_a = spec.paths[path]) === null || _a === void 0 ? void 0 : _a.servers[0]);
+        const operationServer = operationObject.servers && operationObject.servers[0];
+        const serverUrl = operationServer || methodServer || rootServer;
+        if (!serverUrl) {
+            result.reason.push(ErrorType.NoServerInformation);
+        }
+        else {
+            const serverValidateResult = Utils.checkServerUrl([serverUrl]);
+            result.reason.push(...serverValidateResult.map((item) => item.type));
+        }
+        const paramObject = operationObject.parameters;
+        const requestBody = operationObject.requestBody;
+        const requestJsonBody = requestBody === null || requestBody === void 0 ? void 0 : requestBody.content["application/json"];
+        if (!isTeamsAi && Utils.containMultipleMediaTypes(requestBody)) {
+            result.reason.push(ErrorType.PostBodyContainMultipleMediaTypes);
+        }
+        const { json, multipleMediaType } = Utils.getResponseJson(operationObject, isTeamsAi);
+        if (multipleMediaType && !isTeamsAi) {
+            result.reason.push(ErrorType.ResponseContainMultipleMediaTypes);
+        }
+        else if (Object.keys(json).length === 0) {
+            result.reason.push(ErrorType.ResponseJsonIsEmpty);
+        }
+        // Teams AI project doesn't care about request parameters/body
+        if (!isTeamsAi) {
+            let requestBodyParamResult = {
+                requiredNum: 0,
+                optionalNum: 0,
+                isValid: true,
+                reason: [],
+            };
+            if (requestJsonBody) {
+                const requestBodySchema = requestJsonBody.schema;
+                if (isCopilot && requestBodySchema.type !== "object") {
+                    result.reason.push(ErrorType.PostBodySchemaIsNotJson);
                 }
-                // Copilot support arbitrary parameters
-                if (isCopilot) {
-                    return true;
+                requestBodyParamResult = Utils.checkPostBody(requestBodySchema, requestBody.required, isCopilot);
+                if (!requestBodyParamResult.isValid && requestBodyParamResult.reason) {
+                    result.reason.push(...requestBodyParamResult.reason);
                 }
-                if (requestBodyParamResult.requiredNum + paramResult.requiredNum > 1) {
-                    if (options.allowMultipleParameters &&
-                        requestBodyParamResult.requiredNum + paramResult.requiredNum <=
-                            ConstantString.SMERequiredParamsMaxNum) {
-                        return true;
+            }
+            const paramResult = Utils.checkParameters(paramObject, isCopilot);
+            if (!paramResult.isValid && paramResult.reason) {
+                result.reason.push(...paramResult.reason);
+            }
+            // Copilot support arbitrary parameters
+            if (!isCopilot && paramResult.isValid && requestBodyParamResult.isValid) {
+                const totalRequiredParams = requestBodyParamResult.requiredNum + paramResult.requiredNum;
+                const totalParams = totalRequiredParams + requestBodyParamResult.optionalNum + paramResult.optionalNum;
+                if (totalRequiredParams > 1) {
+                    if (!options.allowMultipleParameters ||
+                        totalRequiredParams > ConstantString.SMERequiredParamsMaxNum) {
+                        result.reason.push(ErrorType.ExceededRequiredParamsLimit);
                     }
-                    return false;
                 }
-                else if (requestBodyParamResult.requiredNum +
-                    requestBodyParamResult.optionalNum +
-                    paramResult.requiredNum +
-                    paramResult.optionalNum ===
-                    0) {
-                    return false;
-                }
-                else {
-                    return true;
+                else if (totalParams === 0) {
+                    result.reason.push(ErrorType.NoParameter);
                 }
             }
         }
-        return false;
+        if (result.reason.length > 0) {
+            result.isValid = false;
+        }
+        return result;
     }
     static isSupportedAuth(authSchemeArray, options) {
         if (authSchemeArray.length === 0) {
-            return true;
+            return { isValid: true, reason: [] };
         }
         if (options.allowAPIKeyAuth || options.allowOauth2 || options.allowBearerTokenAuth) {
             // Currently we don't support multiple auth in one operation
             if (authSchemeArray.length > 0 && authSchemeArray.every((auths) => auths.length > 1)) {
-                return false;
+                return {
+                    isValid: false,
+                    reason: [ErrorType.MultipleAuthNotSupported],
+                };
             }
             for (const auths of authSchemeArray) {
                 if (auths.length === 1) {
                     if ((options.allowAPIKeyAuth && Utils.isAPIKeyAuth(auths[0].authScheme)) ||
                         (options.allowOauth2 && Utils.isOAuthWithAuthCodeFlow(auths[0].authScheme)) ||
                         (options.allowBearerTokenAuth && Utils.isBearerTokenAuth(auths[0].authScheme))) {
-                        return true;
+                        return { isValid: true, reason: [] };
                     }
                 }
             }
         }
-        return false;
+        return { isValid: false, reason: [ErrorType.AuthTypeIsNotSupported] };
     }
     static isBearerTokenAuth(authScheme) {
         return authScheme.type === "http" && authScheme.scheme === "bearer";
@@ -430,11 +473,17 @@ class Utils {
     static getResponseJson(operationObject, isTeamsAiProject = false) {
         var _a, _b;
         let json = {};
+        let multipleMediaType = false;
         for (const code of ConstantString.ResponseCodeFor20X) {
             const responseObject = (_a = operationObject === null || operationObject === void 0 ? void 0 : operationObject.responses) === null || _a === void 0 ? void 0 : _a[code];
             if ((_b = responseObject === null || responseObject === void 0 ? void 0 : responseObject.content) === null || _b === void 0 ? void 0 : _b["application/json"]) {
+                multipleMediaType = false;
                 json = responseObject.content["application/json"];
-                if (!isTeamsAiProject && Utils.containMultipleMediaTypes(responseObject)) {
+                if (Utils.containMultipleMediaTypes(responseObject)) {
+                    multipleMediaType = true;
+                    if (isTeamsAiProject) {
+                        break;
+                    }
                     json = {};
                 }
                 else {
@@ -442,7 +491,7 @@ class Utils {
                 }
             }
         }
-        return json;
+        return { json, multipleMediaType };
     }
     static convertPathToCamelCase(path) {
         const pathSegments = path.split(/[./{]/);
@@ -462,10 +511,10 @@ class Utils {
             return undefined;
         }
     }
-    static resolveServerUrl(url) {
+    static resolveEnv(str) {
         const placeHolderReg = /\${{\s*([a-zA-Z_][a-zA-Z0-9_]*)\s*}}/g;
-        let matches = placeHolderReg.exec(url);
-        let newUrl = url;
+        let matches = placeHolderReg.exec(str);
+        let newStr = str;
         while (matches != null) {
             const envVar = matches[1];
             const envVal = process.env[envVar];
@@ -473,17 +522,17 @@ class Utils {
                 throw new Error(Utils.format(ConstantString.ResolveServerUrlFailed, envVar));
             }
             else {
-                newUrl = newUrl.replace(matches[0], envVal);
+                newStr = newStr.replace(matches[0], envVal);
             }
-            matches = placeHolderReg.exec(url);
+            matches = placeHolderReg.exec(str);
         }
-        return newUrl;
+        return newStr;
     }
     static checkServerUrl(servers) {
         const errors = [];
         let serverUrl;
         try {
-            serverUrl = Utils.resolveServerUrl(servers[0].url);
+            serverUrl = Utils.resolveEnv(servers[0].url);
         }
         catch (err) {
             errors.push({
@@ -514,6 +563,7 @@ class Utils {
         return errors;
     }
     static validateServer(spec, options) {
+        var _a;
         const errors = [];
         let hasTopLevelServers = false;
         let hasPathLevelServers = false;
@@ -534,7 +584,7 @@ class Utils {
             }
             for (const method in methods) {
                 const operationObject = methods[method];
-                if (Utils.isSupportedApi(method, path, spec, options)) {
+                if (((_a = options.allowMethods) === null || _a === void 0 ? void 0 : _a.includes(method)) && operationObject) {
                     if ((operationObject === null || operationObject === void 0 ? void 0 : operationObject.servers) && operationObject.servers.length >= 1) {
                         hasOperationLevelServers = true;
                         const serverErrors = Utils.checkServerUrl(operationObject.servers);
@@ -686,15 +736,21 @@ class Utils {
         }
         return [command, warning];
     }
-    static listSupportedAPIs(spec, options) {
+    static listAPIs(spec, options) {
+        var _a;
         const paths = spec.paths;
         const result = {};
         for (const path in paths) {
             const methods = paths[path];
             for (const method in methods) {
-                if (Utils.isSupportedApi(method, path, spec, options)) {
-                    const operationObject = methods[method];
-                    result[`${method.toUpperCase()} ${path}`] = operationObject;
+                const operationObject = methods[method];
+                if (((_a = options.allowMethods) === null || _a === void 0 ? void 0 : _a.includes(method)) && operationObject) {
+                    const validateResult = Utils.isSupportedApi(method, path, spec, options);
+                    result[`${method.toUpperCase()} ${path}`] = {
+                        operation: operationObject,
+                        isValid: validateResult.isValid,
+                        reason: validateResult.reason,
+                    };
                 }
             }
         }
@@ -703,13 +759,13 @@ class Utils {
     static validateSpec(spec, parser, isSwaggerFile, options) {
         const errors = [];
         const warnings = [];
+        const apiMap = Utils.listAPIs(spec, options);
         if (isSwaggerFile) {
             warnings.push({
                 type: WarningType.ConvertSwaggerToOpenAPI,
                 content: ConstantString.ConvertSwaggerToOpenAPI,
             });
         }
-        // Server validation
         const serverErrors = Utils.validateServer(spec, options);
         errors.push(...serverErrors);
         // Remote reference not supported
@@ -723,8 +779,8 @@ class Utils {
             });
         }
         // No supported API
-        const apiMap = Utils.listSupportedAPIs(spec, options);
-        if (Object.keys(apiMap).length === 0) {
+        const validAPIs = Object.entries(apiMap).filter(([, value]) => value.isValid);
+        if (validAPIs.length === 0) {
             errors.push({
                 type: ErrorType.NoSupportedApi,
                 content: ConstantString.NoSupportedApi,
@@ -733,8 +789,8 @@ class Utils {
         // OperationId missing
         const apisMissingOperationId = [];
         for (const key in apiMap) {
-            const pathObjectItem = apiMap[key];
-            if (!pathObjectItem.operationId) {
+            const { operation } = apiMap[key];
+            if (!operation.operationId) {
                 apisMissingOperationId.push(key);
             }
         }
@@ -793,25 +849,32 @@ class Utils {
 // Copyright (c) Microsoft Corporation.
 class SpecFilter {
     static specFilter(filter, unResolveSpec, resolvedSpec, options) {
+        var _a;
         try {
             const newSpec = Object.assign({}, unResolveSpec);
             const newPaths = {};
             for (const filterItem of filter) {
                 const [method, path] = filterItem.split(" ");
                 const methodName = method.toLowerCase();
-                if (!Utils.isSupportedApi(methodName, path, resolvedSpec, options)) {
-                    continue;
-                }
-                if (!newPaths[path]) {
-                    newPaths[path] = Object.assign({}, unResolveSpec.paths[path]);
-                    for (const m of ConstantString.AllOperationMethods) {
-                        delete newPaths[path][m];
+                const pathObj = (_a = resolvedSpec.paths) === null || _a === void 0 ? void 0 : _a[path];
+                if (ConstantString.AllOperationMethods.includes(methodName) &&
+                    pathObj &&
+                    pathObj[methodName]) {
+                    const validateResult = Utils.isSupportedApi(methodName, path, resolvedSpec, options);
+                    if (!validateResult.isValid) {
+                        continue;
+                    }
+                    if (!newPaths[path]) {
+                        newPaths[path] = Object.assign({}, unResolveSpec.paths[path]);
+                        for (const m of ConstantString.AllOperationMethods) {
+                            delete newPaths[path][m];
+                        }
+                    }
+                    newPaths[path][methodName] = unResolveSpec.paths[path][methodName];
+                    // Add the operationId if missing
+                    if (!newPaths[path][methodName].operationId) {
+                        newPaths[path][methodName].operationId = `${methodName}${Utils.convertPathToCamelCase(path)}`;
                     }
-                }
-                newPaths[path][methodName] = unResolveSpec.paths[path][methodName];
-                // Add the operationId if missing
-                if (!newPaths[path][methodName].operationId) {
-                    newPaths[path][methodName].operationId = `${methodName}${Utils.convertPathToCamelCase(path)}`;
                 }
             }
             newSpec.paths = newPaths;
@@ -833,9 +896,10 @@ class ManifestUpdater {
                 pluginFile: apiPluginRelativePath,
             },
         ];
+        const appName = this.removeEnvs(manifest.name.short);
         ManifestUpdater.updateManifestDescription(manifest, spec);
         const specRelativePath = ManifestUpdater.getRelativePath(manifestPath, outputSpecPath);
-        const apiPlugin = ManifestUpdater.generatePluginManifestSchema(spec, specRelativePath, options);
+        const apiPlugin = ManifestUpdater.generatePluginManifestSchema(spec, specRelativePath, appName, options);
         return [manifest, apiPlugin];
     }
     static updateManifestDescription(manifest, spec) {
@@ -859,7 +923,7 @@ class ManifestUpdater {
         }
         return parameter;
     }
-    static generatePluginManifestSchema(spec, specRelativePath, options) {
+    static generatePluginManifestSchema(spec, specRelativePath, appName, options) {
         var _a, _b, _c;
         const functions = [];
         const functionNames = [];
@@ -924,7 +988,7 @@ class ManifestUpdater {
         }
         const apiPlugin = {
             schema_version: "v2",
-            name_for_human: spec.info.title,
+            name_for_human: appName,
             description_for_human: (_c = spec.info.description) !== null && _c !== void 0 ? _c : "<Please add description of the plugin>",
             functions: functions,
             runtimes: [
@@ -1031,13 +1095,22 @@ class ManifestUpdater {
         const relativePath = path.relative(path.dirname(from), to);
         return path.normalize(relativePath).replace(/\\/g, "/");
     }
+    static removeEnvs(str) {
+        const placeHolderReg = /\${{\s*([a-zA-Z_][a-zA-Z0-9_]*)\s*}}/g;
+        const matches = placeHolderReg.exec(str);
+        let newStr = str;
+        if (matches != null) {
+            newStr = newStr.replace(matches[0], "");
+        }
+        return newStr;
+    }
 }
 
 // Copyright (c) Microsoft Corporation.
 class AdaptiveCardGenerator {
     static generateAdaptiveCard(operationItem) {
         try {
-            const json = Utils.getResponseJson(operationItem);
+            const { json } = Utils.getResponseJson(operationItem);
             let cardBody = [];
             let schema = json.schema;
             let jsonPath = "$";
@@ -1370,20 +1443,22 @@ class SpecParser {
         try {
             await this.loadSpec();
             const spec = this.spec;
-            const apiMap = this.getAllSupportedAPIs(spec);
+            const apiMap = this.getAPIs(spec);
             const result = {
-                validAPIs: [],
+                APIs: [],
                 allAPICount: 0,
                 validAPICount: 0,
             };
             for (const apiKey in apiMap) {
+                const { operation, isValid, reason } = apiMap[apiKey];
+                const [method, path] = apiKey.split(" ");
                 const apiResult = {
                     api: "",
                     server: "",
                     operationId: "",
+                    isValid: isValid,
+                    reason: reason,
                 };
-                const [method, path] = apiKey.split(" ");
-                const operation = apiMap[apiKey];
                 const rootServer = spec.servers && spec.servers[0];
                 const methodServer = spec.paths[path].servers && ((_a = spec.paths[path]) === null || _a === void 0 ? void 0 : _a.servers[0]);
                 const operationServer = operation.servers && operation.servers[0];
@@ -1391,7 +1466,7 @@ class SpecParser {
                 if (!serverUrl) {
                     throw new SpecParserError(ConstantString.NoServerInformation, ErrorType.NoServerInformation);
                 }
-                apiResult.server = Utils.resolveServerUrl(serverUrl.url);
+                apiResult.server = Utils.resolveEnv(serverUrl.url);
                 let operationId = operation.operationId;
                 if (!operationId) {
                     operationId = `${method.toLowerCase()}${Utils.convertPathToCamelCase(path)}`;
@@ -1405,10 +1480,10 @@ class SpecParser {
                     }
                 }
                 apiResult.api = apiKey;
-                result.validAPIs.push(apiResult);
+                result.APIs.push(apiResult);
             }
-            result.allAPICount = Utils.getAllAPICount(spec);
-            result.validAPICount = result.validAPIs.length;
+            result.allAPICount = result.APIs.length;
+            result.validAPICount = result.APIs.filter((api) => api.isValid).length;
             return result;
         }
         catch (err) {
@@ -1500,15 +1575,18 @@ class SpecParser {
             const newSpecs = await this.getFilteredSpecs(filter, signal);
             const newUnResolvedSpec = newSpecs[0];
             const newSpec = newSpecs[1];
-            const authSet = new Set();
             let hasMultipleAuth = false;
+            let authInfo = undefined;
             for (const url in newSpec.paths) {
                 for (const method in newSpec.paths[url]) {
                     const operation = newSpec.paths[url][method];
                     const authArray = Utils.getAuthArray(operation.security, newSpec);
                     if (authArray && authArray.length > 0) {
-                        authSet.add(authArray[0][0]);
-                        if (authSet.size > 1) {
+                        const currentAuth = authArray[0][0];
+                        if (!authInfo) {
+                            authInfo = authArray[0][0];
+                        }
+                        else if (authInfo.name !== currentAuth.name) {
                             hasMultipleAuth = true;
                             break;
                         }
@@ -1555,7 +1633,6 @@ class SpecParser {
             if (signal === null || signal === void 0 ? void 0 : signal.aborted) {
                 throw new SpecParserError(ConstantString.CancelledMessage, ErrorType.Cancelled);
             }
-            const authInfo = Array.from(authSet)[0];
             const [updatedManifest, warnings] = await ManifestUpdater.updateManifest(manifestPath, outputSpecPath, newSpec, this.options, adaptiveCardFolder, authInfo);
             await fs.outputJSON(manifestPath, updatedManifest, { spaces: 2 });
             result.warnings.push(...warnings);
@@ -1581,11 +1658,11 @@ class SpecParser {
             this.spec = (await this.parser.dereference(clonedUnResolveSpec));
         }
     }
-    getAllSupportedAPIs(spec) {
+    getAPIs(spec) {
         if (this.apiMap !== undefined) {
             return this.apiMap;
         }
-        const result = Utils.listSupportedAPIs(spec, this.options);
+        const result = Utils.listAPIs(spec, this.options);
         this.apiMap = result;
         return result;
     }