@microsoft/m365-spec-parser 0.1.1-alpha.4f2290daa.0 → 0.1.1-alpha.5fc8ceacd.0

package/dist/index.node.cjs.js

@@ -208,7 +208,8 @@ ConstantString.CommandDescriptionMaxLens = 128;
 ConstantString.ParameterDescriptionMaxLens = 128;
 ConstantString.CommandTitleMaxLens = 32;
 ConstantString.ParameterTitleMaxLens = 32;
-ConstantString.SMERequiredParamsMaxNum = 5;
+ConstantString.SMERequiredParamsMaxNum = 5;
+ConstantString.DefaultPluginId = "plugin_1";
 
 // Copyright (c) Microsoft Corporation.
 class SpecParserError extends Error {
@@ -231,249 +232,9 @@ class Utils {
         }
         return false;
     }
-    static checkParameters(paramObject, isCopilot) {
-        const paramResult = {
-            requiredNum: 0,
-            optionalNum: 0,
-            isValid: true,
-            reason: [],
-        };
-        if (!paramObject) {
-            return paramResult;
-        }
-        for (let i = 0; i < paramObject.length; i++) {
-            const param = paramObject[i];
-            const schema = param.schema;
-            if (isCopilot && this.hasNestedObjectInSchema(schema)) {
-                paramResult.isValid = false;
-                paramResult.reason.push(exports.ErrorType.ParamsContainsNestedObject);
-                continue;
-            }
-            const isRequiredWithoutDefault = param.required && schema.default === undefined;
-            if (isCopilot) {
-                if (isRequiredWithoutDefault) {
-                    paramResult.requiredNum = paramResult.requiredNum + 1;
-                }
-                else {
-                    paramResult.optionalNum = paramResult.optionalNum + 1;
-                }
-                continue;
-            }
-            if (param.in === "header" || param.in === "cookie") {
-                if (isRequiredWithoutDefault) {
-                    paramResult.isValid = false;
-                    paramResult.reason.push(exports.ErrorType.ParamsContainRequiredUnsupportedSchema);
-                }
-                continue;
-            }
-            if (schema.type !== "boolean" &&
-                schema.type !== "string" &&
-                schema.type !== "number" &&
-                schema.type !== "integer") {
-                if (isRequiredWithoutDefault) {
-                    paramResult.isValid = false;
-                    paramResult.reason.push(exports.ErrorType.ParamsContainRequiredUnsupportedSchema);
-                }
-                continue;
-            }
-            if (param.in === "query" || param.in === "path") {
-                if (isRequiredWithoutDefault) {
-                    paramResult.requiredNum = paramResult.requiredNum + 1;
-                }
-                else {
-                    paramResult.optionalNum = paramResult.optionalNum + 1;
-                }
-            }
-        }
-        return paramResult;
-    }
-    static checkPostBody(schema, isRequired = false, isCopilot = false) {
-        var _a;
-        const paramResult = {
-            requiredNum: 0,
-            optionalNum: 0,
-            isValid: true,
-            reason: [],
-        };
-        if (Object.keys(schema).length === 0) {
-            return paramResult;
-        }
-        const isRequiredWithoutDefault = isRequired && schema.default === undefined;
-        if (isCopilot && this.hasNestedObjectInSchema(schema)) {
-            paramResult.isValid = false;
-            paramResult.reason = [exports.ErrorType.RequestBodyContainsNestedObject];
-            return paramResult;
-        }
-        if (schema.type === "string" ||
-            schema.type === "integer" ||
-            schema.type === "boolean" ||
-            schema.type === "number") {
-            if (isRequiredWithoutDefault) {
-                paramResult.requiredNum = paramResult.requiredNum + 1;
-            }
-            else {
-                paramResult.optionalNum = paramResult.optionalNum + 1;
-            }
-        }
-        else if (schema.type === "object") {
-            const { properties } = schema;
-            for (const property in properties) {
-                let isRequired = false;
-                if (schema.required && ((_a = schema.required) === null || _a === void 0 ? void 0 : _a.indexOf(property)) >= 0) {
-                    isRequired = true;
-                }
-                const result = Utils.checkPostBody(properties[property], isRequired, isCopilot);
-                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(exports.ErrorType.PostBodyContainsRequiredUnsupportedSchema);
-            }
-        }
-        return paramResult;
-    }
     static containMultipleMediaTypes(bodyObject) {
         return Object.keys((bodyObject === null || bodyObject === void 0 ? void 0 : bodyObject.content) || {}).length > 1;
     }
-    /**
-     * Checks if the given API is supported.
-     * @param {string} method - The HTTP method of the API.
-     * @param {string} path - The path of the API.
-     * @param {OpenAPIV3.Document} spec - The OpenAPI specification document.
-     * @returns {boolean} - Returns true if the API is supported, false otherwise.
-     * @description The following APIs are supported:
-     * 1. only support Get/Post operation without auth property
-     * 2. parameter inside query or path only support string, number, boolean and integer
-     * 3. parameter inside post body only support string, number, boolean, integer and object
-     * 4. request body + required parameters <= 1
-     * 5. response body should be “application/json” and not empty, and response code should be 20X
-     * 6. only support request body with “application/json” content type
-     */
-    static isSupportedApi(method, path, spec, options) {
-        var _a;
-        const result = { isValid: true, reason: [] };
-        method = method.toLocaleLowerCase();
-        if (options.allowMethods && !options.allowMethods.includes(method)) {
-            result.isValid = false;
-            result.reason.push(exports.ErrorType.MethodNotAllowed);
-            return result;
-        }
-        const pathObj = spec.paths[path];
-        if (!pathObj || !pathObj[method]) {
-            result.isValid = false;
-            result.reason.push(exports.ErrorType.UrlPathNotExist);
-            return result;
-        }
-        const securities = pathObj[method].security;
-        const isTeamsAi = options.projectType === exports.ProjectType.TeamsAi;
-        const isCopilot = options.projectType === exports.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(exports.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(exports.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(exports.ErrorType.PostBodyContainMultipleMediaTypes);
-        }
-        const { json, multipleMediaType } = Utils.getResponseJson(operationObject, isTeamsAi);
-        if (multipleMediaType && !isTeamsAi) {
-            result.reason.push(exports.ErrorType.ResponseContainMultipleMediaTypes);
-        }
-        else if (Object.keys(json).length === 0) {
-            result.reason.push(exports.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(exports.ErrorType.PostBodySchemaIsNotJson);
-                }
-                requestBodyParamResult = Utils.checkPostBody(requestBodySchema, requestBody.required, isCopilot);
-                if (!requestBodyParamResult.isValid && requestBodyParamResult.reason) {
-                    result.reason.push(...requestBodyParamResult.reason);
-                }
-            }
-            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(exports.ErrorType.ExceededRequiredParamsLimit);
-                    }
-                }
-                else if (totalParams === 0) {
-                    result.reason.push(exports.ErrorType.NoParameter);
-                }
-            }
-        }
-        if (result.reason.length > 0) {
-            result.isValid = false;
-        }
-        return result;
-    }
-    static isSupportedAuth(authSchemeArray, options) {
-        if (authSchemeArray.length === 0) {
-            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 {
-                    isValid: false,
-                    reason: [exports.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 { isValid: true, reason: [] };
-                    }
-                }
-            }
-        }
-        return { isValid: false, reason: [exports.ErrorType.AuthTypeIsNotSupported] };
-    }
     static isBearerTokenAuth(authScheme) {
         return authScheme.type === "http" && authScheme.scheme === "bearer";
     }
@@ -481,10 +242,9 @@ class Utils {
         return authScheme.type === "apiKey";
     }
     static isOAuthWithAuthCodeFlow(authScheme) {
-        if (authScheme.type === "oauth2" && authScheme.flows && authScheme.flows.authorizationCode) {
-            return true;
-        }
-        return false;
+        return !!(authScheme.type === "oauth2" &&
+            authScheme.flows &&
+            authScheme.flows.authorizationCode);
     }
     static getAuthArray(securities, spec) {
         var _a;
@@ -512,7 +272,7 @@ class Utils {
     static updateFirstLetter(str) {
         return str.charAt(0).toUpperCase() + str.slice(1);
     }
-    static getResponseJson(operationObject, isTeamsAiProject = false) {
+    static getResponseJson(operationObject) {
         var _a, _b;
         let json = {};
         let multipleMediaType = false;
@@ -523,9 +283,6 @@ class Utils {
                 json = responseObject.content["application/json"];
                 if (Utils.containMultipleMediaTypes(responseObject)) {
                     multipleMediaType = true;
-                    if (isTeamsAiProject) {
-                        break;
-                    }
                     json = {};
                 }
                 else {
@@ -764,16 +521,49 @@ class Utils {
         };
         return command;
     }
-    static listAPIs(spec, options) {
+    static format(str, ...args) {
+        let index = 0;
+        return str.replace(/%s/g, () => {
+            const arg = args[index++];
+            return arg !== undefined ? arg : "";
+        });
+    }
+    static getSafeRegistrationIdEnvName(authName) {
+        if (!authName) {
+            return "";
+        }
+        let safeRegistrationIdEnvName = authName.toUpperCase().replace(/[^A-Z0-9_]/g, "_");
+        if (!safeRegistrationIdEnvName.match(/^[A-Z]/)) {
+            safeRegistrationIdEnvName = "PREFIX_" + safeRegistrationIdEnvName;
+        }
+        return safeRegistrationIdEnvName;
+    }
+    static getServerObject(spec, method, path) {
+        const pathObj = spec.paths[path];
+        const operationObject = pathObj[method];
+        const rootServer = spec.servers && spec.servers[0];
+        const methodServer = spec.paths[path].servers && spec.paths[path].servers[0];
+        const operationServer = operationObject.servers && operationObject.servers[0];
+        const serverUrl = operationServer || methodServer || rootServer;
+        return serverUrl;
+    }
+}
+
+// Copyright (c) Microsoft Corporation.
+class Validator {
+    listAPIs() {
         var _a;
-        const paths = spec.paths;
+        if (this.apiMap) {
+            return this.apiMap;
+        }
+        const paths = this.spec.paths;
         const result = {};
         for (const path in paths) {
             const methods = paths[path];
             for (const method in methods) {
                 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);
+                if (((_a = this.options.allowMethods) === null || _a === void 0 ? void 0 : _a.includes(method)) && operationObject) {
+                    const validateResult = this.validateAPI(method, path);
                     result[`${method.toUpperCase()} ${path}`] = {
                         operation: operationObject,
                         isValid: validateResult.isValid,
@@ -782,38 +572,48 @@ class Utils {
                 }
             }
         }
+        this.apiMap = result;
         return result;
     }
-    static validateSpec(spec, parser, isSwaggerFile, options) {
-        const errors = [];
-        const warnings = [];
-        const apiMap = Utils.listAPIs(spec, options);
-        if (isSwaggerFile) {
-            warnings.push({
-                type: exports.WarningType.ConvertSwaggerToOpenAPI,
-                content: ConstantString.ConvertSwaggerToOpenAPI,
-            });
-        }
-        const serverErrors = Utils.validateServer(spec, options);
-        errors.push(...serverErrors);
-        // Remote reference not supported
-        const refPaths = parser.$refs.paths();
-        // refPaths [0] is the current spec file path
-        if (refPaths.length > 1) {
-            errors.push({
-                type: exports.ErrorType.RemoteRefNotSupported,
-                content: Utils.format(ConstantString.RemoteRefNotSupported, refPaths.join(", ")),
-                data: refPaths,
+    validateSpecVersion() {
+        const result = { errors: [], warnings: [] };
+        if (this.spec.openapi >= "3.1.0") {
+            result.errors.push({
+                type: exports.ErrorType.SpecVersionNotSupported,
+                content: Utils.format(ConstantString.SpecVersionNotSupported, this.spec.openapi),
+                data: this.spec.openapi,
             });
         }
-        // No supported API
+        return result;
+    }
+    validateSpecServer() {
+        const result = { errors: [], warnings: [] };
+        const serverErrors = Utils.validateServer(this.spec, this.options);
+        result.errors.push(...serverErrors);
+        return result;
+    }
+    validateSpecNoSupportAPI() {
+        const result = { errors: [], warnings: [] };
+        const apiMap = this.listAPIs();
         const validAPIs = Object.entries(apiMap).filter(([, value]) => value.isValid);
         if (validAPIs.length === 0) {
-            errors.push({
+            const data = [];
+            for (const key in apiMap) {
+                const { reason } = apiMap[key];
+                const apiInvalidReason = { api: key, reason: reason };
+                data.push(apiInvalidReason);
+            }
+            result.errors.push({
                 type: exports.ErrorType.NoSupportedApi,
                 content: ConstantString.NoSupportedApi,
+                data,
             });
         }
+        return result;
+    }
+    validateSpecOperationId() {
+        const result = { errors: [], warnings: [] };
+        const apiMap = this.listAPIs();
         // OperationId missing
         const apisMissingOperationId = [];
         for (const key in apiMap) {
@@ -823,54 +623,431 @@ class Utils {
             }
         }
         if (apisMissingOperationId.length > 0) {
-            warnings.push({
+            result.warnings.push({
                 type: exports.WarningType.OperationIdMissing,
                 content: Utils.format(ConstantString.MissingOperationId, apisMissingOperationId.join(", ")),
                 data: apisMissingOperationId,
             });
         }
-        let status = exports.ValidationStatus.Valid;
-        if (warnings.length > 0 && errors.length === 0) {
-            status = exports.ValidationStatus.Warning;
+        return result;
+    }
+    validateMethodAndPath(method, path) {
+        const result = { isValid: true, reason: [] };
+        if (this.options.allowMethods && !this.options.allowMethods.includes(method)) {
+            result.isValid = false;
+            result.reason.push(exports.ErrorType.MethodNotAllowed);
+            return result;
         }
-        else if (errors.length > 0) {
-            status = exports.ValidationStatus.Error;
+        const pathObj = this.spec.paths[path];
+        if (!pathObj || !pathObj[method]) {
+            result.isValid = false;
+            result.reason.push(exports.ErrorType.UrlPathNotExist);
+            return result;
         }
-        return {
-            status,
-            warnings,
-            errors,
-        };
+        return result;
     }
-    static format(str, ...args) {
-        let index = 0;
-        return str.replace(/%s/g, () => {
-            const arg = args[index++];
-            return arg !== undefined ? arg : "";
-        });
+    validateResponse(method, path) {
+        const result = { isValid: true, reason: [] };
+        const operationObject = this.spec.paths[path][method];
+        const { json, multipleMediaType } = Utils.getResponseJson(operationObject);
+        // only support response body only contains “application/json” content type
+        if (multipleMediaType) {
+            result.reason.push(exports.ErrorType.ResponseContainMultipleMediaTypes);
+        }
+        else if (Object.keys(json).length === 0) {
+            // response body should not be empty
+            result.reason.push(exports.ErrorType.ResponseJsonIsEmpty);
+        }
+        return result;
     }
-    static getSafeRegistrationIdEnvName(authName) {
-        if (!authName) {
-            return "";
+    validateServer(method, path) {
+        const result = { isValid: true, reason: [] };
+        const serverObj = Utils.getServerObject(this.spec, method, path);
+        if (!serverObj) {
+            // should contain server URL
+            result.reason.push(exports.ErrorType.NoServerInformation);
         }
-        let safeRegistrationIdEnvName = authName.toUpperCase().replace(/[^A-Z0-9_]/g, "_");
-        if (!safeRegistrationIdEnvName.match(/^[A-Z]/)) {
-            safeRegistrationIdEnvName = "PREFIX_" + safeRegistrationIdEnvName;
+        else {
+            // server url should be absolute url with https protocol
+            const serverValidateResult = Utils.checkServerUrl([serverObj]);
+            result.reason.push(...serverValidateResult.map((item) => item.type));
         }
-        return safeRegistrationIdEnvName;
+        return result;
     }
-    static getAllAPICount(spec) {
-        let count = 0;
-        const paths = spec.paths;
-        for (const path in paths) {
-            const methods = paths[path];
-            for (const method in methods) {
-                if (ConstantString.AllOperationMethods.includes(method)) {
-                    count++;
+    validateAuth(method, path) {
+        const pathObj = this.spec.paths[path];
+        const operationObject = pathObj[method];
+        const securities = operationObject.security;
+        const authSchemeArray = Utils.getAuthArray(securities, this.spec);
+        if (authSchemeArray.length === 0) {
+            return { isValid: true, reason: [] };
+        }
+        if (this.options.allowAPIKeyAuth ||
+            this.options.allowOauth2 ||
+            this.options.allowBearerTokenAuth) {
+            // Currently we don't support multiple auth in one operation
+            if (authSchemeArray.length > 0 && authSchemeArray.every((auths) => auths.length > 1)) {
+                return {
+                    isValid: false,
+                    reason: [exports.ErrorType.MultipleAuthNotSupported],
+                };
+            }
+            for (const auths of authSchemeArray) {
+                if (auths.length === 1) {
+                    if ((this.options.allowAPIKeyAuth && Utils.isAPIKeyAuth(auths[0].authScheme)) ||
+                        (this.options.allowOauth2 && Utils.isOAuthWithAuthCodeFlow(auths[0].authScheme)) ||
+                        (this.options.allowBearerTokenAuth && Utils.isBearerTokenAuth(auths[0].authScheme))) {
+                        return { isValid: true, reason: [] };
+                    }
+                }
+            }
+        }
+        return { isValid: false, reason: [exports.ErrorType.AuthTypeIsNotSupported] };
+    }
+    checkPostBodySchema(schema, isRequired = false) {
+        var _a;
+        const paramResult = {
+            requiredNum: 0,
+            optionalNum: 0,
+            isValid: true,
+            reason: [],
+        };
+        if (Object.keys(schema).length === 0) {
+            return paramResult;
+        }
+        const isRequiredWithoutDefault = isRequired && schema.default === undefined;
+        const isCopilot = this.projectType === exports.ProjectType.Copilot;
+        if (isCopilot && this.hasNestedObjectInSchema(schema)) {
+            paramResult.isValid = false;
+            paramResult.reason = [exports.ErrorType.RequestBodyContainsNestedObject];
+            return paramResult;
+        }
+        if (schema.type === "string" ||
+            schema.type === "integer" ||
+            schema.type === "boolean" ||
+            schema.type === "number") {
+            if (isRequiredWithoutDefault) {
+                paramResult.requiredNum = paramResult.requiredNum + 1;
+            }
+            else {
+                paramResult.optionalNum = paramResult.optionalNum + 1;
+            }
+        }
+        else if (schema.type === "object") {
+            const { properties } = schema;
+            for (const property in properties) {
+                let isRequired = false;
+                if (schema.required && ((_a = schema.required) === null || _a === void 0 ? void 0 : _a.indexOf(property)) >= 0) {
+                    isRequired = true;
+                }
+                const result = this.checkPostBodySchema(properties[property], isRequired);
+                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(exports.ErrorType.PostBodyContainsRequiredUnsupportedSchema);
+            }
+        }
+        return paramResult;
+    }
+    checkParamSchema(paramObject) {
+        const paramResult = {
+            requiredNum: 0,
+            optionalNum: 0,
+            isValid: true,
+            reason: [],
+        };
+        if (!paramObject) {
+            return paramResult;
+        }
+        const isCopilot = this.projectType === exports.ProjectType.Copilot;
+        for (let i = 0; i < paramObject.length; i++) {
+            const param = paramObject[i];
+            const schema = param.schema;
+            if (isCopilot && this.hasNestedObjectInSchema(schema)) {
+                paramResult.isValid = false;
+                paramResult.reason.push(exports.ErrorType.ParamsContainsNestedObject);
+                continue;
+            }
+            const isRequiredWithoutDefault = param.required && schema.default === undefined;
+            if (isCopilot) {
+                if (isRequiredWithoutDefault) {
+                    paramResult.requiredNum = paramResult.requiredNum + 1;
+                }
+                else {
+                    paramResult.optionalNum = paramResult.optionalNum + 1;
+                }
+                continue;
+            }
+            if (param.in === "header" || param.in === "cookie") {
+                if (isRequiredWithoutDefault) {
+                    paramResult.isValid = false;
+                    paramResult.reason.push(exports.ErrorType.ParamsContainRequiredUnsupportedSchema);
+                }
+                continue;
+            }
+            if (schema.type !== "boolean" &&
+                schema.type !== "string" &&
+                schema.type !== "number" &&
+                schema.type !== "integer") {
+                if (isRequiredWithoutDefault) {
+                    paramResult.isValid = false;
+                    paramResult.reason.push(exports.ErrorType.ParamsContainRequiredUnsupportedSchema);
+                }
+                continue;
+            }
+            if (param.in === "query" || param.in === "path") {
+                if (isRequiredWithoutDefault) {
+                    paramResult.requiredNum = paramResult.requiredNum + 1;
+                }
+                else {
+                    paramResult.optionalNum = paramResult.optionalNum + 1;
                 }
             }
         }
-        return count;
+        return paramResult;
+    }
+    hasNestedObjectInSchema(schema) {
+        if (schema.type === "object") {
+            for (const property in schema.properties) {
+                const nestedSchema = schema.properties[property];
+                if (nestedSchema.type === "object") {
+                    return true;
+                }
+            }
+        }
+        return false;
+    }
+}
+
+// Copyright (c) Microsoft Corporation.
+class CopilotValidator extends Validator {
+    constructor(spec, options) {
+        super();
+        this.projectType = exports.ProjectType.Copilot;
+        this.options = options;
+        this.spec = spec;
+    }
+    validateSpec() {
+        const result = { errors: [], warnings: [] };
+        // validate spec version
+        let validationResult = this.validateSpecVersion();
+        result.errors.push(...validationResult.errors);
+        // validate spec server
+        validationResult = this.validateSpecServer();
+        result.errors.push(...validationResult.errors);
+        // validate no supported API
+        validationResult = this.validateSpecNoSupportAPI();
+        result.errors.push(...validationResult.errors);
+        // validate operationId missing
+        validationResult = this.validateSpecOperationId();
+        result.warnings.push(...validationResult.warnings);
+        return result;
+    }
+    validateAPI(method, path) {
+        const result = { isValid: true, reason: [] };
+        method = method.toLocaleLowerCase();
+        // validate method and path
+        const methodAndPathResult = this.validateMethodAndPath(method, path);
+        if (!methodAndPathResult.isValid) {
+            return methodAndPathResult;
+        }
+        const operationObject = this.spec.paths[path][method];
+        // validate auth
+        const authCheckResult = this.validateAuth(method, path);
+        result.reason.push(...authCheckResult.reason);
+        // validate operationId
+        if (!this.options.allowMissingId && !operationObject.operationId) {
+            result.reason.push(exports.ErrorType.MissingOperationId);
+        }
+        // validate server
+        const validateServerResult = this.validateServer(method, path);
+        result.reason.push(...validateServerResult.reason);
+        // validate response
+        const validateResponseResult = this.validateResponse(method, path);
+        result.reason.push(...validateResponseResult.reason);
+        // validate requestBody
+        const requestBody = operationObject.requestBody;
+        const requestJsonBody = requestBody === null || requestBody === void 0 ? void 0 : requestBody.content["application/json"];
+        if (Utils.containMultipleMediaTypes(requestBody)) {
+            result.reason.push(exports.ErrorType.PostBodyContainMultipleMediaTypes);
+        }
+        if (requestJsonBody) {
+            const requestBodySchema = requestJsonBody.schema;
+            if (requestBodySchema.type !== "object") {
+                result.reason.push(exports.ErrorType.PostBodySchemaIsNotJson);
+            }
+            const requestBodyParamResult = this.checkPostBodySchema(requestBodySchema, requestBody.required);
+            result.reason.push(...requestBodyParamResult.reason);
+        }
+        // validate parameters
+        const paramObject = operationObject.parameters;
+        const paramResult = this.checkParamSchema(paramObject);
+        result.reason.push(...paramResult.reason);
+        if (result.reason.length > 0) {
+            result.isValid = false;
+        }
+        return result;
+    }
+}
+
+// Copyright (c) Microsoft Corporation.
+class SMEValidator extends Validator {
+    constructor(spec, options) {
+        super();
+        this.projectType = exports.ProjectType.SME;
+        this.options = options;
+        this.spec = spec;
+    }
+    validateSpec() {
+        const result = { errors: [], warnings: [] };
+        // validate spec version
+        let validationResult = this.validateSpecVersion();
+        result.errors.push(...validationResult.errors);
+        // validate spec server
+        validationResult = this.validateSpecServer();
+        result.errors.push(...validationResult.errors);
+        // validate no supported API
+        validationResult = this.validateSpecNoSupportAPI();
+        result.errors.push(...validationResult.errors);
+        // validate operationId missing
+        if (this.options.allowMissingId) {
+            validationResult = this.validateSpecOperationId();
+            result.warnings.push(...validationResult.warnings);
+        }
+        return result;
+    }
+    validateAPI(method, path) {
+        const result = { isValid: true, reason: [] };
+        method = method.toLocaleLowerCase();
+        // validate method and path
+        const methodAndPathResult = this.validateMethodAndPath(method, path);
+        if (!methodAndPathResult.isValid) {
+            return methodAndPathResult;
+        }
+        const operationObject = this.spec.paths[path][method];
+        // validate auth
+        const authCheckResult = this.validateAuth(method, path);
+        result.reason.push(...authCheckResult.reason);
+        // validate operationId
+        if (!this.options.allowMissingId && !operationObject.operationId) {
+            result.reason.push(exports.ErrorType.MissingOperationId);
+        }
+        // validate server
+        const validateServerResult = this.validateServer(method, path);
+        result.reason.push(...validateServerResult.reason);
+        // validate response
+        const validateResponseResult = this.validateResponse(method, path);
+        result.reason.push(...validateResponseResult.reason);
+        let postBodyResult = {
+            requiredNum: 0,
+            optionalNum: 0,
+            isValid: true,
+            reason: [],
+        };
+        // validate requestBody
+        const requestBody = operationObject.requestBody;
+        const requestJsonBody = requestBody === null || requestBody === void 0 ? void 0 : requestBody.content["application/json"];
+        if (Utils.containMultipleMediaTypes(requestBody)) {
+            result.reason.push(exports.ErrorType.PostBodyContainMultipleMediaTypes);
+        }
+        if (requestJsonBody) {
+            const requestBodySchema = requestJsonBody.schema;
+            postBodyResult = this.checkPostBodySchema(requestBodySchema, requestBody.required);
+            result.reason.push(...postBodyResult.reason);
+        }
+        // validate parameters
+        const paramObject = operationObject.parameters;
+        const paramResult = this.checkParamSchema(paramObject);
+        result.reason.push(...paramResult.reason);
+        // validate total parameters count
+        if (paramResult.isValid && postBodyResult.isValid) {
+            const paramCountResult = this.validateParamCount(postBodyResult, paramResult);
+            result.reason.push(...paramCountResult.reason);
+        }
+        if (result.reason.length > 0) {
+            result.isValid = false;
+        }
+        return result;
+    }
+    validateParamCount(postBodyResult, paramResult) {
+        const result = { isValid: true, reason: [] };
+        const totalRequiredParams = postBodyResult.requiredNum + paramResult.requiredNum;
+        const totalParams = totalRequiredParams + postBodyResult.optionalNum + paramResult.optionalNum;
+        if (totalRequiredParams > 1) {
+            if (!this.options.allowMultipleParameters ||
+                totalRequiredParams > SMEValidator.SMERequiredParamsMaxNum) {
+                result.reason.push(exports.ErrorType.ExceededRequiredParamsLimit);
+            }
+        }
+        else if (totalParams === 0) {
+            result.reason.push(exports.ErrorType.NoParameter);
+        }
+        return result;
+    }
+}
+SMEValidator.SMERequiredParamsMaxNum = 5;
+
+// Copyright (c) Microsoft Corporation.
+class TeamsAIValidator extends Validator {
+    constructor(spec, options) {
+        super();
+        this.projectType = exports.ProjectType.TeamsAi;
+        this.options = options;
+        this.spec = spec;
+    }
+    validateSpec() {
+        const result = { errors: [], warnings: [] };
+        // validate spec server
+        let validationResult = this.validateSpecServer();
+        result.errors.push(...validationResult.errors);
+        // validate no supported API
+        validationResult = this.validateSpecNoSupportAPI();
+        result.errors.push(...validationResult.errors);
+        return result;
+    }
+    validateAPI(method, path) {
+        const result = { isValid: true, reason: [] };
+        method = method.toLocaleLowerCase();
+        // validate method and path
+        const methodAndPathResult = this.validateMethodAndPath(method, path);
+        if (!methodAndPathResult.isValid) {
+            return methodAndPathResult;
+        }
+        const operationObject = this.spec.paths[path][method];
+        // validate operationId
+        if (!this.options.allowMissingId && !operationObject.operationId) {
+            result.reason.push(exports.ErrorType.MissingOperationId);
+        }
+        // validate server
+        const validateServerResult = this.validateServer(method, path);
+        result.reason.push(...validateServerResult.reason);
+        if (result.reason.length > 0) {
+            result.isValid = false;
+        }
+        return result;
+    }
+}
+
+class ValidatorFactory {
+    static create(spec, options) {
+        var _a;
+        const type = (_a = options.projectType) !== null && _a !== void 0 ? _a : exports.ProjectType.SME;
+        switch (type) {
+            case exports.ProjectType.SME:
+                return new SMEValidator(spec, options);
+            case exports.ProjectType.Copilot:
+                return new CopilotValidator(spec, options);
+            case exports.ProjectType.TeamsAi:
+                return new TeamsAIValidator(spec, options);
+            default:
+                throw new Error(`Invalid project type: ${type}`);
+        }
     }
 }
 
@@ -888,7 +1065,8 @@ class SpecFilter {
                 if (ConstantString.AllOperationMethods.includes(methodName) &&
                     pathObj &&
                     pathObj[methodName]) {
-                    const validateResult = Utils.isSupportedApi(methodName, path, resolvedSpec, options);
+                    const validator = ValidatorFactory.create(resolvedSpec, options);
+                    const validateResult = validator.validateAPI(methodName, path);
                     if (!validateResult.isValid) {
                         continue;
                     }
@@ -922,13 +1100,14 @@ class ManifestUpdater {
             const apiPluginRelativePath = ManifestUpdater.getRelativePath(manifestPath, apiPluginFilePath);
             manifest.plugins = [
                 {
-                    pluginFile: apiPluginRelativePath,
+                    file: apiPluginRelativePath,
+                    id: ConstantString.DefaultPluginId,
                 },
             ];
             const appName = this.removeEnvs(manifest.name.short);
             ManifestUpdater.updateManifestDescription(manifest, spec);
             const specRelativePath = ManifestUpdater.getRelativePath(manifestPath, outputSpecPath);
-            const apiPlugin = ManifestUpdater.generatePluginManifestSchema(spec, specRelativePath, appName, options);
+            const apiPlugin = yield ManifestUpdater.generatePluginManifestSchema(spec, specRelativePath, apiPluginFilePath, appName, options);
             return [manifest, apiPlugin];
         });
     }
@@ -953,88 +1132,119 @@ class ManifestUpdater {
         }
         return parameter;
     }
-    static generatePluginManifestSchema(spec, specRelativePath, appName, options) {
-        var _a, _b, _c;
-        const functions = [];
-        const functionNames = [];
-        const paths = spec.paths;
-        for (const pathUrl in paths) {
-            const pathItem = paths[pathUrl];
-            if (pathItem) {
-                const operations = pathItem;
-                for (const method in operations) {
-                    if (options.allowMethods.includes(method)) {
-                        const operationItem = operations[method];
-                        if (operationItem) {
-                            const operationId = operationItem.operationId;
-                            const description = (_a = operationItem.description) !== null && _a !== void 0 ? _a : "";
-                            const paramObject = operationItem.parameters;
-                            const requestBody = operationItem.requestBody;
-                            const parameters = {
-                                type: "object",
-                                properties: {},
-                                required: [],
-                            };
-                            if (paramObject) {
-                                for (let i = 0; i < paramObject.length; i++) {
-                                    const param = paramObject[i];
-                                    const schema = param.schema;
-                                    parameters.properties[param.name] = ManifestUpdater.mapOpenAPISchemaToFuncParam(schema, method, pathUrl);
-                                    if (param.required) {
-                                        parameters.required.push(param.name);
-                                    }
-                                    if (!parameters.properties[param.name].description) {
-                                        parameters.properties[param.name].description = (_b = param.description) !== null && _b !== void 0 ? _b : "";
+    static generatePluginManifestSchema(spec, specRelativePath, apiPluginFilePath, appName, options) {
+        var _a, _b, _c, _d;
+        return __awaiter(this, void 0, void 0, function* () {
+            const functions = [];
+            const functionNames = [];
+            const paths = spec.paths;
+            for (const pathUrl in paths) {
+                const pathItem = paths[pathUrl];
+                if (pathItem) {
+                    const operations = pathItem;
+                    for (const method in operations) {
+                        if (options.allowMethods.includes(method)) {
+                            const operationItem = operations[method];
+                            if (operationItem) {
+                                const operationId = operationItem.operationId;
+                                const description = (_a = operationItem.description) !== null && _a !== void 0 ? _a : "";
+                                const paramObject = operationItem.parameters;
+                                const requestBody = operationItem.requestBody;
+                                const parameters = {
+                                    type: "object",
+                                    properties: {},
+                                    required: [],
+                                };
+                                if (paramObject) {
+                                    for (let i = 0; i < paramObject.length; i++) {
+                                        const param = paramObject[i];
+                                        const schema = param.schema;
+                                        parameters.properties[param.name] = ManifestUpdater.mapOpenAPISchemaToFuncParam(schema, method, pathUrl);
+                                        if (param.required) {
+                                            parameters.required.push(param.name);
+                                        }
+                                        if (!parameters.properties[param.name].description) {
+                                            parameters.properties[param.name].description = (_b = param.description) !== null && _b !== void 0 ? _b : "";
+                                        }
                                     }
                                 }
-                            }
-                            if (requestBody) {
-                                const requestJsonBody = requestBody.content["application/json"];
-                                const requestBodySchema = requestJsonBody.schema;
-                                if (requestBodySchema.type === "object") {
-                                    if (requestBodySchema.required) {
-                                        parameters.required.push(...requestBodySchema.required);
+                                if (requestBody) {
+                                    const requestJsonBody = requestBody.content["application/json"];
+                                    const requestBodySchema = requestJsonBody.schema;
+                                    if (requestBodySchema.type === "object") {
+                                        if (requestBodySchema.required) {
+                                            parameters.required.push(...requestBodySchema.required);
+                                        }
+                                        for (const property in requestBodySchema.properties) {
+                                            const schema = requestBodySchema.properties[property];
+                                            parameters.properties[property] = ManifestUpdater.mapOpenAPISchemaToFuncParam(schema, method, pathUrl);
+                                        }
                                     }
-                                    for (const property in requestBodySchema.properties) {
-                                        const schema = requestBodySchema.properties[property];
-                                        parameters.properties[property] = ManifestUpdater.mapOpenAPISchemaToFuncParam(schema, method, pathUrl);
+                                    else {
+                                        throw new SpecParserError(Utils.format(ConstantString.UnsupportedSchema, method, pathUrl, JSON.stringify(requestBodySchema)), exports.ErrorType.UpdateManifestFailed);
                                     }
                                 }
-                                else {
-                                    throw new SpecParserError(Utils.format(ConstantString.UnsupportedSchema, method, pathUrl, JSON.stringify(requestBodySchema)), exports.ErrorType.UpdateManifestFailed);
-                                }
+                                const funcObj = {
+                                    name: operationId,
+                                    description: description,
+                                    parameters: parameters,
+                                };
+                                functions.push(funcObj);
+                                functionNames.push(operationId);
                             }
-                            const funcObj = {
-                                name: operationId,
-                                description: description,
-                                parameters: parameters,
-                            };
-                            functions.push(funcObj);
-                            functionNames.push(operationId);
                         }
                     }
                 }
             }
-        }
-        const apiPlugin = {
-            schema_version: "v2",
-            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: [
-                {
+            let apiPlugin;
+            if (yield fs__default['default'].pathExists(apiPluginFilePath)) {
+                apiPlugin = yield fs__default['default'].readJSON(apiPluginFilePath);
+            }
+            else {
+                apiPlugin = {
+                    schema_version: "v2",
+                    name_for_human: "",
+                    description_for_human: "",
+                    functions: [],
+                    runtimes: [],
+                };
+            }
+            apiPlugin.functions = apiPlugin.functions || [];
+            for (const func of functions) {
+                const index = (_c = apiPlugin.functions) === null || _c === void 0 ? void 0 : _c.findIndex((f) => f.name === func.name);
+                if (index === -1) {
+                    apiPlugin.functions.push(func);
+                }
+                else {
+                    apiPlugin.functions[index] = func;
+                }
+            }
+            apiPlugin.runtimes = apiPlugin.runtimes || [];
+            const index = apiPlugin.runtimes.findIndex((runtime) => runtime.spec.url === specRelativePath);
+            if (index === -1) {
+                apiPlugin.runtimes.push({
                     type: "OpenApi",
                     auth: {
-                        type: "none", // TODO, support auth in the future
+                        type: "none",
                     },
                     spec: {
                         url: specRelativePath,
                     },
                     run_for_functions: functionNames,
-                },
-            ],
-        };
-        return apiPlugin;
+                });
+            }
+            else {
+                apiPlugin.runtimes[index].run_for_functions = functionNames;
+            }
+            if (!apiPlugin.name_for_human) {
+                apiPlugin.name_for_human = appName;
+            }
+            if (!apiPlugin.description_for_human) {
+                apiPlugin.description_for_human =
+                    (_d = spec.info.description) !== null && _d !== void 0 ? _d : "<Please add description of the plugin>";
+            }
+            return apiPlugin;
+        });
     }
     static updateManifest(manifestPath, outputSpecPath, spec, options, adaptiveCardFolder, authInfo) {
         return __awaiter(this, void 0, void 0, function* () {
@@ -1443,6 +1653,8 @@ class SpecParser {
                         errors: [{ type: exports.ErrorType.SpecNotValid, content: e.toString() }],
                     };
                 }
+                const errors = [];
+                const warnings = [];
                 if (!this.options.allowSwagger && this.isSwaggerFile) {
                     return {
                         status: exports.ValidationStatus.Error,
@@ -1452,23 +1664,38 @@ class SpecParser {
                         ],
                     };
                 }
-                if (this.options.projectType === exports.ProjectType.SME ||
-                    this.options.projectType === exports.ProjectType.Copilot) {
-                    if (this.spec.openapi >= "3.1.0") {
-                        return {
-                            status: exports.ValidationStatus.Error,
-                            warnings: [],
-                            errors: [
-                                {
-                                    type: exports.ErrorType.SpecVersionNotSupported,
-                                    content: Utils.format(ConstantString.SpecVersionNotSupported, this.spec.openapi),
-                                    data: this.spec.openapi,
-                                },
-                            ],
-                        };
-                    }
+                // Remote reference not supported
+                const refPaths = this.parser.$refs.paths();
+                // refPaths [0] is the current spec file path
+                if (refPaths.length > 1) {
+                    errors.push({
+                        type: exports.ErrorType.RemoteRefNotSupported,
+                        content: Utils.format(ConstantString.RemoteRefNotSupported, refPaths.join(", ")),
+                        data: refPaths,
+                    });
                 }
-                return Utils.validateSpec(this.spec, this.parser, !!this.isSwaggerFile, this.options);
+                if (!!this.isSwaggerFile && this.options.allowSwagger) {
+                    warnings.push({
+                        type: exports.WarningType.ConvertSwaggerToOpenAPI,
+                        content: ConstantString.ConvertSwaggerToOpenAPI,
+                    });
+                }
+                const validator = this.getValidator(this.spec);
+                const validationResult = validator.validateSpec();
+                warnings.push(...validationResult.warnings);
+                errors.push(...validationResult.errors);
+                let status = exports.ValidationStatus.Valid;
+                if (warnings.length > 0 && errors.length === 0) {
+                    status = exports.ValidationStatus.Warning;
+                }
+                else if (errors.length > 0) {
+                    status = exports.ValidationStatus.Error;
+                }
+                return {
+                    status: status,
+                    warnings: warnings,
+                    errors: errors,
+                };
             }
             catch (err) {
                 throw new SpecParserError(err.toString(), exports.ErrorType.ValidateFailed);
@@ -1501,34 +1728,27 @@ class SpecParser {
                 for (const apiKey in apiMap) {
                     const { operation, isValid, reason } = apiMap[apiKey];
                     const [method, path] = apiKey.split(" ");
+                    const operationId = (_a = operation.operationId) !== null && _a !== void 0 ? _a : `${method.toLowerCase()}${Utils.convertPathToCamelCase(path)}`;
                     const apiResult = {
-                        api: "",
+                        api: apiKey,
                         server: "",
-                        operationId: "",
+                        operationId: operationId,
                         isValid: isValid,
                         reason: reason,
                     };
-                    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];
-                    const serverUrl = operationServer || methodServer || rootServer;
-                    if (!serverUrl) {
-                        throw new SpecParserError(ConstantString.NoServerInformation, exports.ErrorType.NoServerInformation);
-                    }
-                    apiResult.server = Utils.resolveEnv(serverUrl.url);
-                    let operationId = operation.operationId;
-                    if (!operationId) {
-                        operationId = `${method.toLowerCase()}${Utils.convertPathToCamelCase(path)}`;
-                    }
-                    apiResult.operationId = operationId;
-                    const authArray = Utils.getAuthArray(operation.security, spec);
-                    for (const auths of authArray) {
-                        if (auths.length === 1) {
-                            apiResult.auth = auths[0];
-                            break;
+                    if (isValid) {
+                        const serverObj = Utils.getServerObject(spec, method.toLocaleLowerCase(), path);
+                        if (serverObj) {
+                            apiResult.server = Utils.resolveEnv(serverObj.url);
+                        }
+                        const authArray = Utils.getAuthArray(operation.security, spec);
+                        for (const auths of authArray) {
+                            if (auths.length === 1) {
+                                apiResult.auth = auths[0];
+                                break;
+                            }
                         }
                     }
-                    apiResult.api = apiKey;
                     result.APIs.push(apiResult);
                 }
                 result.allAPICount = result.APIs.length;
@@ -1717,12 +1937,18 @@ class SpecParser {
         });
     }
     getAPIs(spec) {
-        if (this.apiMap !== undefined) {
-            return this.apiMap;
+        const validator = this.getValidator(spec);
+        const apiMap = validator.listAPIs();
+        this.apiMap = apiMap;
+        return apiMap;
+    }
+    getValidator(spec) {
+        if (this.validator) {
+            return this.validator;
         }
-        const result = Utils.listAPIs(spec, this.options);
-        this.apiMap = result;
-        return result;
+        const validator = ValidatorFactory.create(spec, this.options);
+        this.validator = validator;
+        return validator;
     }
 }