@microsoft/m365-spec-parser 0.0.2-alpha.0

package/dist/index.esm5.js

@@ -0,0 +1,886 @@
+import SwaggerParser from '@apidevtools/swagger-parser';
+
+/******************************************************************************
+Copyright (c) Microsoft Corporation.
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+PERFORMANCE OF THIS SOFTWARE.
+***************************************************************************** */
+
+function __awaiter(thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+}
+
+typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
+    var e = new Error(message);
+    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
+};
+
+// Copyright (c) Microsoft Corporation.
+/**
+ * An enum that represents the types of errors that can occur during validation.
+ */
+var ErrorType;
+(function (ErrorType) {
+    ErrorType["SpecNotValid"] = "spec-not-valid";
+    ErrorType["RemoteRefNotSupported"] = "remote-ref-not-supported";
+    ErrorType["NoServerInformation"] = "no-server-information";
+    ErrorType["UrlProtocolNotSupported"] = "url-protocol-not-supported";
+    ErrorType["RelativeServerUrlNotSupported"] = "relative-server-url-not-supported";
+    ErrorType["NoSupportedApi"] = "no-supported-api";
+    ErrorType["NoExtraAPICanBeAdded"] = "no-extra-api-can-be-added";
+    ErrorType["ResolveServerUrlFailed"] = "resolve-server-url-failed";
+    ErrorType["SwaggerNotSupported"] = "swagger-not-supported";
+    ErrorType["MultipleAPIKeyNotSupported"] = "multiple-api-key-not-supported";
+    ErrorType["ListFailed"] = "list-failed";
+    ErrorType["listSupportedAPIInfoFailed"] = "list-supported-api-info-failed";
+    ErrorType["FilterSpecFailed"] = "filter-spec-failed";
+    ErrorType["UpdateManifestFailed"] = "update-manifest-failed";
+    ErrorType["GenerateAdaptiveCardFailed"] = "generate-adaptive-card-failed";
+    ErrorType["GenerateFailed"] = "generate-failed";
+    ErrorType["ValidateFailed"] = "validate-failed";
+    ErrorType["Cancelled"] = "cancelled";
+    ErrorType["Unknown"] = "unknown";
+})(ErrorType || (ErrorType = {}));
+/**
+ * An enum that represents the types of warnings that can occur during validation.
+ */
+var WarningType;
+(function (WarningType) {
+    WarningType["OperationIdMissing"] = "operationid-missing";
+    WarningType["GenerateCardFailed"] = "generate-card-failed";
+    WarningType["OperationOnlyContainsOptionalParam"] = "operation-only-contains-optional-param";
+    WarningType["ConvertSwaggerToOpenAPI"] = "convert-swagger-to-openapi";
+    WarningType["Unknown"] = "unknown";
+})(WarningType || (WarningType = {}));
+/**
+ * An enum that represents the validation status of an OpenAPI specification file.
+ */
+var ValidationStatus;
+(function (ValidationStatus) {
+    ValidationStatus[ValidationStatus["Valid"] = 0] = "Valid";
+    ValidationStatus[ValidationStatus["Warning"] = 1] = "Warning";
+    ValidationStatus[ValidationStatus["Error"] = 2] = "Error";
+})(ValidationStatus || (ValidationStatus = {}));
+
+// Copyright (c) Microsoft Corporation.
+class SpecParserError extends Error {
+    constructor(message, errorType) {
+        super(message);
+        this.errorType = errorType;
+    }
+}
+
+// Copyright (c) Microsoft Corporation.
+class ConstantString {
+}
+ConstantString.CancelledMessage = "Operation is cancelled.";
+ConstantString.NoServerInformation = "No server information is found in the OpenAPI description document.";
+ConstantString.RemoteRefNotSupported = "Remote reference is not supported: %s.";
+ConstantString.MissingOperationId = "Missing operationIds: %s.";
+ConstantString.NoSupportedApi = "No supported API is found in the OpenAPI description document: only GET and POST methods are supported, additionally, there can be at most one required parameter, and no auth is allowed.";
+ConstantString.AdditionalPropertiesNotSupported = "'additionalProperties' is not supported, and will be ignored.";
+ConstantString.SchemaNotSupported = "'oneOf', 'anyOf', and 'not' schema are not supported: %s.";
+ConstantString.UnknownSchema = "Unknown schema: %s.";
+ConstantString.UrlProtocolNotSupported = "Server url is not correct: protocol %s is not supported, you should use https protocol instead.";
+ConstantString.RelativeServerUrlNotSupported = "Server url is not correct: relative server url is not supported.";
+ConstantString.ResolveServerUrlFailed = "Unable to resolve the server URL: please make sure that the environment variable %s is defined.";
+ConstantString.OperationOnlyContainsOptionalParam = "Operation %s contains multiple optional parameters. The first optional parameter is used for this command.";
+ConstantString.ConvertSwaggerToOpenAPI = "The Swagger 2.0 file has been converted to OpenAPI 3.0.";
+ConstantString.SwaggerNotSupported = "Swagger 2.0 is not supported. Please convert to OpenAPI 3.0 manually before proceeding.";
+ConstantString.MultipleAPIKeyNotSupported = "Multiple API keys are not supported. Please make sure that all selected APIs use the same API key.";
+ConstantString.WrappedCardVersion = "devPreview";
+ConstantString.WrappedCardSchema = "https://developer.microsoft.com/json-schemas/teams/vDevPreview/MicrosoftTeams.ResponseRenderingTemplate.schema.json";
+ConstantString.WrappedCardResponseLayout = "list";
+ConstantString.GetMethod = "get";
+ConstantString.PostMethod = "post";
+ConstantString.AdaptiveCardVersion = "1.5";
+ConstantString.AdaptiveCardSchema = "http://adaptivecards.io/schemas/adaptive-card.json";
+ConstantString.AdaptiveCardType = "AdaptiveCard";
+ConstantString.TextBlockType = "TextBlock";
+ConstantString.ContainerType = "Container";
+ConstantString.RegistrationIdPostfix = "REGISTRATION_ID";
+ConstantString.ResponseCodeFor20X = [
+    "200",
+    "201",
+    "202",
+    "203",
+    "204",
+    "205",
+    "206",
+    "207",
+    "208",
+    "226",
+    "default",
+];
+ConstantString.AllOperationMethods = [
+    "get",
+    "post",
+    "put",
+    "delete",
+    "patch",
+    "head",
+    "options",
+    "trace",
+];
+// TODO: update after investigating the usage of these constants.
+ConstantString.WellknownResultNames = [
+    "result",
+    "data",
+    "items",
+    "root",
+    "matches",
+    "queries",
+    "list",
+    "output",
+];
+ConstantString.WellknownTitleName = ["title", "name", "summary", "caption", "subject", "label"];
+ConstantString.WellknownSubtitleName = [
+    "subtitle",
+    "id",
+    "uid",
+    "description",
+    "desc",
+    "detail",
+];
+ConstantString.WellknownImageName = [
+    "image",
+    "icon",
+    "avatar",
+    "picture",
+    "photo",
+    "logo",
+    "pic",
+    "thumbnail",
+    "img",
+];
+ConstantString.ShortDescriptionMaxLens = 80;
+ConstantString.FullDescriptionMaxLens = 4000;
+ConstantString.CommandDescriptionMaxLens = 128;
+ConstantString.ParameterDescriptionMaxLens = 128;
+ConstantString.CommandTitleMaxLens = 32;
+ConstantString.ParameterTitleMaxLens = 32;
+
+// Copyright (c) Microsoft Corporation.
+class Utils {
+    static checkParameters(paramObject) {
+        const paramResult = {
+            requiredNum: 0,
+            optionalNum: 0,
+            isValid: true,
+        };
+        if (!paramObject) {
+            return paramResult;
+        }
+        for (let i = 0; i < paramObject.length; i++) {
+            const param = paramObject[i];
+            const schema = param.schema;
+            const isRequiredWithoutDefault = param.required && schema.default === undefined;
+            if (param.in === "header" || param.in === "cookie") {
+                if (isRequiredWithoutDefault) {
+                    paramResult.isValid = false;
+                }
+                continue;
+            }
+            if (schema.type !== "boolean" &&
+                schema.type !== "string" &&
+                schema.type !== "number" &&
+                schema.type !== "integer") {
+                if (isRequiredWithoutDefault) {
+                    paramResult.isValid = false;
+                }
+                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) {
+        var _a;
+        const paramResult = {
+            requiredNum: 0,
+            optionalNum: 0,
+            isValid: true,
+        };
+        if (Object.keys(schema).length === 0) {
+            return paramResult;
+        }
+        const isRequiredWithoutDefault = isRequired && schema.default === undefined;
+        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);
+                paramResult.requiredNum += result.requiredNum;
+                paramResult.optionalNum += result.optionalNum;
+                paramResult.isValid = paramResult.isValid && result.isValid;
+            }
+        }
+        else {
+            if (isRequiredWithoutDefault) {
+                paramResult.isValid = false;
+            }
+        }
+        return paramResult;
+    }
+    /**
+     * 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, allowMissingId, allowAPIKeyAuth, allowMultipleParameters, allowOauth2) {
+        const pathObj = spec.paths[path];
+        method = method.toLocaleLowerCase();
+        if (pathObj) {
+            if ((method === ConstantString.PostMethod || method === ConstantString.GetMethod) &&
+                pathObj[method]) {
+                const securities = pathObj[method].security;
+                const authArray = Utils.getAuthArray(securities, spec);
+                if (!Utils.isSupportedAuth(authArray, allowAPIKeyAuth, allowOauth2)) {
+                    return false;
+                }
+                const operationObject = pathObj[method];
+                if (!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"];
+                const mediaTypesCount = Object.keys((requestBody === null || requestBody === void 0 ? void 0 : requestBody.content) || {}).length;
+                if (mediaTypesCount > 1) {
+                    return false;
+                }
+                const responseJson = Utils.getResponseJson(operationObject);
+                if (Object.keys(responseJson).length === 0) {
+                    return false;
+                }
+                let requestBodyParamResult = {
+                    requiredNum: 0,
+                    optionalNum: 0,
+                    isValid: true,
+                };
+                if (requestJsonBody) {
+                    const requestBodySchema = requestJsonBody.schema;
+                    requestBodyParamResult = Utils.checkPostBody(requestBodySchema, requestBody.required);
+                }
+                if (!requestBodyParamResult.isValid) {
+                    return false;
+                }
+                const paramResult = Utils.checkParameters(paramObject);
+                if (!paramResult.isValid) {
+                    return false;
+                }
+                if (requestBodyParamResult.requiredNum + paramResult.requiredNum > 1) {
+                    if (allowMultipleParameters &&
+                        requestBodyParamResult.requiredNum + paramResult.requiredNum <= 5) {
+                        return true;
+                    }
+                    return false;
+                }
+                else if (requestBodyParamResult.requiredNum +
+                    requestBodyParamResult.optionalNum +
+                    paramResult.requiredNum +
+                    paramResult.optionalNum ===
+                    0) {
+                    return false;
+                }
+                else {
+                    return true;
+                }
+            }
+        }
+        return false;
+    }
+    static isSupportedAuth(authSchemaArray, allowAPIKeyAuth, allowOauth2) {
+        if (authSchemaArray.length === 0) {
+            return true;
+        }
+        if (allowAPIKeyAuth || allowOauth2) {
+            // Currently we don't support multiple auth in one operation
+            if (authSchemaArray.length > 0 && authSchemaArray.every((auths) => auths.length > 1)) {
+                return false;
+            }
+            for (const auths of authSchemaArray) {
+                if (auths.length === 1) {
+                    if (!allowOauth2 && allowAPIKeyAuth && Utils.isAPIKeyAuth(auths[0].authSchema)) {
+                        return true;
+                    }
+                    else if (!allowAPIKeyAuth && allowOauth2 && Utils.isBearerTokenAuth(auths[0].authSchema)) {
+                        return true;
+                    }
+                    else if (allowAPIKeyAuth &&
+                        allowOauth2 &&
+                        (Utils.isAPIKeyAuth(auths[0].authSchema) || Utils.isBearerTokenAuth(auths[0].authSchema))) {
+                        return true;
+                    }
+                }
+            }
+        }
+        return false;
+    }
+    static isAPIKeyAuth(authSchema) {
+        return authSchema.type === "apiKey";
+    }
+    static isBearerTokenAuth(authSchema) {
+        return (authSchema.type === "oauth2" ||
+            authSchema.type === "openIdConnect" ||
+            (authSchema.type === "http" && authSchema.scheme === "bearer"));
+    }
+    static getAuthArray(securities, spec) {
+        var _a;
+        const result = [];
+        const securitySchemas = (_a = spec.components) === null || _a === void 0 ? void 0 : _a.securitySchemes;
+        if (securities && securitySchemas) {
+            for (let i = 0; i < securities.length; i++) {
+                const security = securities[i];
+                const authArray = [];
+                for (const name in security) {
+                    const auth = securitySchemas[name];
+                    authArray.push({
+                        authSchema: auth,
+                        name: name,
+                    });
+                }
+                if (authArray.length > 0) {
+                    result.push(authArray);
+                }
+            }
+        }
+        result.sort((a, b) => a[0].name.localeCompare(b[0].name));
+        return result;
+    }
+    static updateFirstLetter(str) {
+        return str.charAt(0).toUpperCase() + str.slice(1);
+    }
+    static getResponseJson(operationObject) {
+        var _a, _b;
+        let json = {};
+        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];
+            const mediaTypesCount = Object.keys((responseObject === null || responseObject === void 0 ? void 0 : responseObject.content) || {}).length;
+            if (mediaTypesCount > 1) {
+                return {};
+            }
+            if ((_b = responseObject === null || responseObject === void 0 ? void 0 : responseObject.content) === null || _b === void 0 ? void 0 : _b["application/json"]) {
+                json = responseObject.content["application/json"];
+                break;
+            }
+        }
+        return json;
+    }
+    static convertPathToCamelCase(path) {
+        const pathSegments = path.split(/[./{]/);
+        const camelCaseSegments = pathSegments.map((segment) => {
+            segment = segment.replace(/}/g, "");
+            return segment.charAt(0).toUpperCase() + segment.slice(1);
+        });
+        const camelCasePath = camelCaseSegments.join("");
+        return camelCasePath;
+    }
+    static getUrlProtocol(urlString) {
+        try {
+            const url = new URL(urlString);
+            return url.protocol;
+        }
+        catch (err) {
+            return undefined;
+        }
+    }
+    static resolveServerUrl(url) {
+        const placeHolderReg = /\${{\s*([a-zA-Z_][a-zA-Z0-9_]*)\s*}}/g;
+        let matches = placeHolderReg.exec(url);
+        let newUrl = url;
+        while (matches != null) {
+            const envVar = matches[1];
+            const envVal = process.env[envVar];
+            if (!envVal) {
+                throw new Error(Utils.format(ConstantString.ResolveServerUrlFailed, envVar));
+            }
+            else {
+                newUrl = newUrl.replace(matches[0], envVal);
+            }
+            matches = placeHolderReg.exec(url);
+        }
+        return newUrl;
+    }
+    static checkServerUrl(servers) {
+        const errors = [];
+        let serverUrl;
+        try {
+            serverUrl = Utils.resolveServerUrl(servers[0].url);
+        }
+        catch (err) {
+            errors.push({
+                type: ErrorType.ResolveServerUrlFailed,
+                content: err.message,
+                data: servers,
+            });
+            return errors;
+        }
+        const protocol = Utils.getUrlProtocol(serverUrl);
+        if (!protocol) {
+            // Relative server url is not supported
+            errors.push({
+                type: ErrorType.RelativeServerUrlNotSupported,
+                content: ConstantString.RelativeServerUrlNotSupported,
+                data: servers,
+            });
+        }
+        else if (protocol !== "https:") {
+            // Http server url is not supported
+            const protocolString = protocol.slice(0, -1);
+            errors.push({
+                type: ErrorType.UrlProtocolNotSupported,
+                content: Utils.format(ConstantString.UrlProtocolNotSupported, protocol.slice(0, -1)),
+                data: protocolString,
+            });
+        }
+        return errors;
+    }
+    static validateServer(spec, allowMissingId, allowAPIKeyAuth, allowMultipleParameters, allowOauth2) {
+        const errors = [];
+        let hasTopLevelServers = false;
+        let hasPathLevelServers = false;
+        let hasOperationLevelServers = false;
+        if (spec.servers && spec.servers.length >= 1) {
+            hasTopLevelServers = true;
+            // for multiple server, we only use the first url
+            const serverErrors = Utils.checkServerUrl(spec.servers);
+            errors.push(...serverErrors);
+        }
+        const paths = spec.paths;
+        for (const path in paths) {
+            const methods = paths[path];
+            if ((methods === null || methods === void 0 ? void 0 : methods.servers) && methods.servers.length >= 1) {
+                hasPathLevelServers = true;
+                const serverErrors = Utils.checkServerUrl(methods.servers);
+                errors.push(...serverErrors);
+            }
+            for (const method in methods) {
+                const operationObject = methods[method];
+                if (Utils.isSupportedApi(method, path, spec, allowMissingId, allowAPIKeyAuth, allowMultipleParameters, allowOauth2)) {
+                    if ((operationObject === null || operationObject === void 0 ? void 0 : operationObject.servers) && operationObject.servers.length >= 1) {
+                        hasOperationLevelServers = true;
+                        const serverErrors = Utils.checkServerUrl(operationObject.servers);
+                        errors.push(...serverErrors);
+                    }
+                }
+            }
+        }
+        if (!hasTopLevelServers && !hasPathLevelServers && !hasOperationLevelServers) {
+            errors.push({
+                type: ErrorType.NoServerInformation,
+                content: ConstantString.NoServerInformation,
+            });
+        }
+        return errors;
+    }
+    static isWellKnownName(name, wellknownNameList) {
+        for (let i = 0; i < wellknownNameList.length; i++) {
+            name = name.replace(/_/g, "").replace(/-/g, "");
+            if (name.toLowerCase().includes(wellknownNameList[i])) {
+                return true;
+            }
+        }
+        return false;
+    }
+    static generateParametersFromSchema(schema, name, allowMultipleParameters, isRequired = false) {
+        var _a, _b;
+        const requiredParams = [];
+        const optionalParams = [];
+        if (schema.type === "string" ||
+            schema.type === "integer" ||
+            schema.type === "boolean" ||
+            schema.type === "number") {
+            const parameter = {
+                name: name,
+                title: Utils.updateFirstLetter(name).slice(0, ConstantString.ParameterTitleMaxLens),
+                description: ((_a = schema.description) !== null && _a !== void 0 ? _a : "").slice(0, ConstantString.ParameterDescriptionMaxLens),
+            };
+            if (allowMultipleParameters) {
+                Utils.updateParameterWithInputType(schema, parameter);
+            }
+            if (isRequired && schema.default === undefined) {
+                requiredParams.push(parameter);
+            }
+            else {
+                optionalParams.push(parameter);
+            }
+        }
+        else if (schema.type === "object") {
+            const { properties } = schema;
+            for (const property in properties) {
+                let isRequired = false;
+                if (schema.required && ((_b = schema.required) === null || _b === void 0 ? void 0 : _b.indexOf(property)) >= 0) {
+                    isRequired = true;
+                }
+                const [requiredP, optionalP] = Utils.generateParametersFromSchema(properties[property], property, allowMultipleParameters, isRequired);
+                requiredParams.push(...requiredP);
+                optionalParams.push(...optionalP);
+            }
+        }
+        return [requiredParams, optionalParams];
+    }
+    static updateParameterWithInputType(schema, param) {
+        if (schema.enum) {
+            param.inputType = "choiceset";
+            param.choices = [];
+            for (let i = 0; i < schema.enum.length; i++) {
+                param.choices.push({
+                    title: schema.enum[i],
+                    value: schema.enum[i],
+                });
+            }
+        }
+        else if (schema.type === "string") {
+            param.inputType = "text";
+        }
+        else if (schema.type === "integer" || schema.type === "number") {
+            param.inputType = "number";
+        }
+        else if (schema.type === "boolean") {
+            param.inputType = "toggle";
+        }
+        if (schema.default) {
+            param.value = schema.default;
+        }
+    }
+    static parseApiInfo(operationItem, allowMultipleParameters) {
+        var _a, _b;
+        const requiredParams = [];
+        const optionalParams = [];
+        const paramObject = operationItem.parameters;
+        if (paramObject) {
+            paramObject.forEach((param) => {
+                var _a;
+                const parameter = {
+                    name: param.name,
+                    title: Utils.updateFirstLetter(param.name).slice(0, ConstantString.ParameterTitleMaxLens),
+                    description: ((_a = param.description) !== null && _a !== void 0 ? _a : "").slice(0, ConstantString.ParameterDescriptionMaxLens),
+                };
+                const schema = param.schema;
+                if (allowMultipleParameters && schema) {
+                    Utils.updateParameterWithInputType(schema, parameter);
+                }
+                if (param.in !== "header" && param.in !== "cookie") {
+                    if (param.required && (schema === null || schema === void 0 ? void 0 : schema.default) === undefined) {
+                        requiredParams.push(parameter);
+                    }
+                    else {
+                        optionalParams.push(parameter);
+                    }
+                }
+            });
+        }
+        if (operationItem.requestBody) {
+            const requestBody = operationItem.requestBody;
+            const requestJson = requestBody.content["application/json"];
+            if (Object.keys(requestJson).length !== 0) {
+                const schema = requestJson.schema;
+                const [requiredP, optionalP] = Utils.generateParametersFromSchema(schema, "requestBody", allowMultipleParameters, requestBody.required);
+                requiredParams.push(...requiredP);
+                optionalParams.push(...optionalP);
+            }
+        }
+        const operationId = operationItem.operationId;
+        const parameters = [];
+        if (requiredParams.length !== 0) {
+            parameters.push(...requiredParams);
+        }
+        else {
+            parameters.push(optionalParams[0]);
+        }
+        const command = {
+            context: ["compose"],
+            type: "query",
+            title: ((_a = operationItem.summary) !== null && _a !== void 0 ? _a : "").slice(0, ConstantString.CommandTitleMaxLens),
+            id: operationId,
+            parameters: parameters,
+            description: ((_b = operationItem.description) !== null && _b !== void 0 ? _b : "").slice(0, ConstantString.CommandDescriptionMaxLens),
+        };
+        let warning = undefined;
+        if (requiredParams.length === 0 && optionalParams.length > 1) {
+            warning = {
+                type: WarningType.OperationOnlyContainsOptionalParam,
+                content: Utils.format(ConstantString.OperationOnlyContainsOptionalParam, operationId),
+                data: operationId,
+            };
+        }
+        return [command, warning];
+    }
+    static listSupportedAPIs(spec, allowMissingId, allowAPIKeyAuth, allowMultipleParameters, allowOauth2) {
+        const paths = spec.paths;
+        const result = {};
+        for (const path in paths) {
+            const methods = paths[path];
+            for (const method in methods) {
+                // For developer preview, only support GET operation with only 1 parameter without auth
+                if (Utils.isSupportedApi(method, path, spec, allowMissingId, allowAPIKeyAuth, allowMultipleParameters, allowOauth2)) {
+                    const operationObject = methods[method];
+                    result[`${method.toUpperCase()} ${path}`] = operationObject;
+                }
+            }
+        }
+        return result;
+    }
+    static validateSpec(spec, parser, isSwaggerFile, allowMissingId, allowAPIKeyAuth, allowMultipleParameters, allowOauth2) {
+        const errors = [];
+        const warnings = [];
+        if (isSwaggerFile) {
+            warnings.push({
+                type: WarningType.ConvertSwaggerToOpenAPI,
+                content: ConstantString.ConvertSwaggerToOpenAPI,
+            });
+        }
+        // Server validation
+        const serverErrors = Utils.validateServer(spec, allowMissingId, allowAPIKeyAuth, allowMultipleParameters, allowOauth2);
+        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: ErrorType.RemoteRefNotSupported,
+                content: Utils.format(ConstantString.RemoteRefNotSupported, refPaths.join(", ")),
+                data: refPaths,
+            });
+        }
+        // No supported API
+        const apiMap = Utils.listSupportedAPIs(spec, allowMissingId, allowAPIKeyAuth, allowMultipleParameters, allowOauth2);
+        if (Object.keys(apiMap).length === 0) {
+            errors.push({
+                type: ErrorType.NoSupportedApi,
+                content: ConstantString.NoSupportedApi,
+            });
+        }
+        // OperationId missing
+        const apisMissingOperationId = [];
+        for (const key in apiMap) {
+            const pathObjectItem = apiMap[key];
+            if (!pathObjectItem.operationId) {
+                apisMissingOperationId.push(key);
+            }
+        }
+        if (apisMissingOperationId.length > 0) {
+            warnings.push({
+                type: WarningType.OperationIdMissing,
+                content: Utils.format(ConstantString.MissingOperationId, apisMissingOperationId.join(", ")),
+                data: apisMissingOperationId,
+            });
+        }
+        let status = ValidationStatus.Valid;
+        if (warnings.length > 0 && errors.length === 0) {
+            status = ValidationStatus.Warning;
+        }
+        else if (errors.length > 0) {
+            status = ValidationStatus.Error;
+        }
+        return {
+            status,
+            warnings,
+            errors,
+        };
+    }
+    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;
+    }
+}
+
+// Copyright (c) Microsoft Corporation.
+/**
+ * A class that parses an OpenAPI specification file and provides methods to validate, list, and generate artifacts.
+ */
+class SpecParser {
+    /**
+     * Creates a new instance of the SpecParser class.
+     * @param pathOrDoc The path to the OpenAPI specification file or the OpenAPI specification object.
+     * @param options The options for parsing the OpenAPI specification file.
+     */
+    constructor(pathOrDoc, options) {
+        this.defaultOptions = {
+            allowMissingId: false,
+            allowSwagger: false,
+            allowAPIKeyAuth: false,
+            allowMultipleParameters: false,
+            allowOauth2: false,
+        };
+        this.pathOrSpec = pathOrDoc;
+        this.parser = new SwaggerParser();
+        this.options = Object.assign(Object.assign({}, this.defaultOptions), (options !== null && options !== void 0 ? options : {}));
+    }
+    /**
+     * Validates the OpenAPI specification file and returns a validation result.
+     *
+     * @returns A validation result object that contains information about any errors or warnings in the specification file.
+     */
+    validate() {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                try {
+                    yield this.loadSpec();
+                    yield this.parser.validate(this.spec);
+                }
+                catch (e) {
+                    return {
+                        status: ValidationStatus.Error,
+                        warnings: [],
+                        errors: [{ type: ErrorType.SpecNotValid, content: e.toString() }],
+                    };
+                }
+                if (!this.options.allowSwagger && this.isSwaggerFile) {
+                    return {
+                        status: ValidationStatus.Error,
+                        warnings: [],
+                        errors: [
+                            { type: ErrorType.SwaggerNotSupported, content: ConstantString.SwaggerNotSupported },
+                        ],
+                    };
+                }
+                return Utils.validateSpec(this.spec, this.parser, !!this.isSwaggerFile, this.options.allowMissingId, this.options.allowAPIKeyAuth, this.options.allowMultipleParameters, this.options.allowOauth2);
+            }
+            catch (err) {
+                throw new SpecParserError(err.toString(), ErrorType.ValidateFailed);
+            }
+        });
+    }
+    listSupportedAPIInfo() {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                yield this.loadSpec();
+                const apiMap = this.getAllSupportedAPIs(this.spec);
+                const apiInfos = [];
+                for (const key in apiMap) {
+                    const pathObjectItem = apiMap[key];
+                    const [method, path] = key.split(" ");
+                    const operationId = pathObjectItem.operationId;
+                    // In Browser environment, this api is by default not support api without operationId
+                    if (!operationId) {
+                        continue;
+                    }
+                    const [command, warning] = Utils.parseApiInfo(pathObjectItem, this.options.allowMultipleParameters);
+                    const apiInfo = {
+                        method: method,
+                        path: path,
+                        title: command.title,
+                        id: operationId,
+                        parameters: command.parameters,
+                        description: command.description,
+                    };
+                    if (warning) {
+                        apiInfo.warning = warning;
+                    }
+                    apiInfos.push(apiInfo);
+                }
+                return apiInfos;
+            }
+            catch (err) {
+                throw new SpecParserError(err.toString(), ErrorType.listSupportedAPIInfoFailed);
+            }
+        });
+    }
+    /**
+     * Lists all the OpenAPI operations in the specification file.
+     * @returns A string array that represents the HTTP method and path of each operation, such as ['GET /pets/{petId}', 'GET /user/{userId}']
+     * according to copilot plugin spec, only list get and post method without auth
+     */
+    // eslint-disable-next-line @typescript-eslint/require-await
+    list() {
+        return __awaiter(this, void 0, void 0, function* () {
+            throw new Error("Method not implemented.");
+        });
+    }
+    /**
+     * Generates and update artifacts from the OpenAPI specification file. Generate Adaptive Cards, update Teams app manifest, and generate a new OpenAPI specification file.
+     * @param manifestPath A file path of the Teams app manifest file to update.
+     * @param filter An array of strings that represent the filters to apply when generating the artifacts. If filter is empty, it would process nothing.
+     * @param outputSpecPath File path of the new OpenAPI specification file to generate. If not specified or empty, no spec file will be generated.
+     * @param adaptiveCardFolder Folder path where the Adaptive Card files will be generated. If not specified or empty, Adaptive Card files will not be generated.
+     */
+    // eslint-disable-next-line @typescript-eslint/require-await
+    generate(manifestPath, filter, outputSpecPath, adaptiveCardFolder, signal) {
+        return __awaiter(this, void 0, void 0, function* () {
+            throw new Error("Method not implemented.");
+        });
+    }
+    loadSpec() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.spec) {
+                this.unResolveSpec = (yield this.parser.parse(this.pathOrSpec));
+                if (!this.unResolveSpec.openapi && this.unResolveSpec.swagger === "2.0") {
+                    this.isSwaggerFile = true;
+                }
+                const clonedUnResolveSpec = JSON.parse(JSON.stringify(this.unResolveSpec));
+                this.spec = (yield this.parser.dereference(clonedUnResolveSpec));
+            }
+        });
+    }
+    getAllSupportedAPIs(spec) {
+        if (this.apiMap !== undefined) {
+            return this.apiMap;
+        }
+        const result = Utils.listSupportedAPIs(spec, this.options.allowMissingId, this.options.allowAPIKeyAuth, this.options.allowMultipleParameters, this.options.allowOauth2);
+        this.apiMap = result;
+        return result;
+    }
+}
+
+export { ConstantString, ErrorType, SpecParser, SpecParserError, ValidationStatus, WarningType };
+//# sourceMappingURL=index.esm5.js.map