@microsoft/m365-spec-parser 0.2.3 → 0.2.4-alpha.679dc7df6.0

package/dist/index.esm2017.js

@@ -32,11 +32,8 @@ var ErrorType;
     ErrorType["PostBodyContainMultipleMediaTypes"] = "post-body-contain-multiple-media-types";
     ErrorType["ResponseContainMultipleMediaTypes"] = "response-contain-multiple-media-types";
     ErrorType["ResponseJsonIsEmpty"] = "response-json-is-empty";
-    ErrorType["PostBodySchemaIsNotJson"] = "post-body-schema-is-not-json";
     ErrorType["PostBodyContainsRequiredUnsupportedSchema"] = "post-body-contains-required-unsupported-schema";
     ErrorType["ParamsContainRequiredUnsupportedSchema"] = "params-contain-required-unsupported-schema";
-    ErrorType["ParamsContainsNestedObject"] = "params-contains-nested-object";
-    ErrorType["RequestBodyContainsNestedObject"] = "request-body-contains-nested-object";
     ErrorType["ExceededRequiredParamsLimit"] = "exceeded-required-params-limit";
     ErrorType["NoParameter"] = "no-parameter";
     ErrorType["NoAPIInfo"] = "no-api-info";
@@ -55,6 +52,9 @@ var WarningType;
     WarningType["OperationOnlyContainsOptionalParam"] = "operation-only-contains-optional-param";
     WarningType["ConvertSwaggerToOpenAPI"] = "convert-swagger-to-openapi";
     WarningType["FuncDescriptionTooLong"] = "function-description-too-long";
+    WarningType["OperationIdContainsSpecialCharacters"] = "operationid-contains-special-characters";
+    WarningType["UnsupportedAuthType"] = "unsupported-auth-type";
+    WarningType["GenerateJsonDataFailed"] = "generate-json-data-failed";
     WarningType["Unknown"] = "unknown";
 })(WarningType || (WarningType = {}));
 /**
@@ -100,25 +100,23 @@ ConstantString.ConvertSwaggerToOpenAPI = "The Swagger 2.0 file has been converte
 ConstantString.SwaggerNotSupported = "Swagger 2.0 is not supported. Please convert to OpenAPI 3.0 manually before proceeding.";
 ConstantString.SpecVersionNotSupported = "Unsupported OpenAPI version %s. Please use version 3.0.x.";
 ConstantString.MultipleAuthNotSupported = "Multiple authentication methods are unsupported. Ensure all selected APIs use identical authentication.";
+ConstantString.OperationIdContainsSpecialCharacters = "Operation id '%s' in OpenAPI description document contained special characters and was renamed to '%s'.";
+ConstantString.AuthTypeIsNotSupported = "Unsupported authorization type in API '%s'. No authorization will be used.";
 ConstantString.UnsupportedSchema = "Unsupported schema in %s %s: %s";
 ConstantString.FuncDescriptionTooLong = "The description of the function '%s' is too long. The current length is %s characters, while the maximum allowed length is %s characters.";
+ConstantString.GenerateJsonDataFailed = "Failed to generate JSON data for api: %s due to %s.";
 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.AdaptiveCardSchema = "https://adaptivecards.io/schemas/adaptive-card.json";
 ConstantString.AdaptiveCardType = "AdaptiveCard";
 ConstantString.TextBlockType = "TextBlock";
 ConstantString.ImageType = "Image";
 ConstantString.ContainerType = "Container";
-ConstantString.RegistrationIdPostfix = {
-    apiKey: "REGISTRATION_ID",
-    oauth2: "CONFIGURATION_ID",
-    http: "REGISTRATION_ID",
-    openIdConnect: "REGISTRATION_ID",
-};
+ConstantString.RegistrationIdPostfix = "REGISTRATION_ID";
 ConstantString.ResponseCodeFor20X = [
     "200",
     "201",
@@ -187,16 +185,8 @@ ConstantString.PluginManifestSchema = "https://developer.microsoft.com/json-sche
 
 // Copyright (c) Microsoft Corporation.
 class Utils {
-    static 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;
+    static isObjectSchema(schema) {
+        return schema.type === "object" || (!schema.type && !!schema.properties);
     }
     static containMultipleMediaTypes(bodyObject) {
         return Object.keys((bodyObject === null || bodyObject === void 0 ? void 0 : bodyObject.content) || {}).length > 1;
@@ -212,6 +202,23 @@ class Utils {
             authScheme.flows &&
             authScheme.flows.authorizationCode);
     }
+    static isNotSupportedAuth(authSchemeArray) {
+        if (authSchemeArray.length === 0) {
+            return false;
+        }
+        if (authSchemeArray.length > 0 && authSchemeArray.every((auths) => auths.length > 1)) {
+            return true;
+        }
+        for (const auths of authSchemeArray) {
+            if (auths.length === 1) {
+                if (Utils.isOAuthWithAuthCodeFlow(auths[0].authScheme) ||
+                    Utils.isBearerTokenAuth(auths[0].authScheme)) {
+                    return false;
+                }
+            }
+        }
+        return true;
+    }
     static getAuthArray(securities, spec) {
         var _a;
         const result = [];
@@ -236,6 +243,20 @@ class Utils {
         result.sort((a, b) => a[0].name.localeCompare(b[0].name));
         return result;
     }
+    static getAuthMap(spec) {
+        const authMap = {};
+        for (const url in spec.paths) {
+            for (const method in spec.paths[url]) {
+                const operation = spec.paths[url][method];
+                const authArray = Utils.getAuthArray(operation.security, spec);
+                if (authArray && authArray.length > 0) {
+                    const currentAuth = authArray[0][0];
+                    authMap[operation.operationId] = currentAuth;
+                }
+            }
+        }
+        return authMap;
+    }
     static getAuthInfo(spec) {
         let authInfo = undefined;
         for (const url in spec.paths) {
@@ -264,27 +285,33 @@ class Utils {
         let multipleMediaType = false;
         for (const code of ConstantString.ResponseCodeFor20X) {
             const responseObject = (_a = operationObject === null || operationObject === void 0 ? void 0 : operationObject.responses) === null || _a === void 0 ? void 0 : _a[code];
-            if (responseObject === null || responseObject === void 0 ? void 0 : responseObject.content) {
-                for (const contentType of Object.keys(responseObject.content)) {
-                    // json media type can also be "application/json; charset=utf-8"
-                    if (contentType.indexOf("application/json") >= 0) {
-                        multipleMediaType = false;
-                        json = responseObject.content[contentType];
-                        if (Utils.containMultipleMediaTypes(responseObject)) {
-                            multipleMediaType = true;
-                            if (!allowMultipleMediaType) {
-                                json = {};
-                            }
-                        }
-                        else {
-                            return { json, multipleMediaType };
-                        }
-                    }
-                }
+            if (!responseObject) {
+                continue;
+            }
+            multipleMediaType = Utils.containMultipleMediaTypes(responseObject);
+            if (!allowMultipleMediaType && multipleMediaType) {
+                json = {};
+                continue;
+            }
+            const mediaObj = Utils.getJsonContentType(responseObject);
+            if (Object.keys(mediaObj).length > 0) {
+                json = mediaObj;
+                return { json, multipleMediaType };
             }
         }
         return { json, multipleMediaType };
     }
+    static getJsonContentType(responseObject) {
+        if (responseObject.content) {
+            for (const contentType of Object.keys(responseObject.content)) {
+                // json media type can also be "application/json; charset=utf-8"
+                if (contentType.indexOf("application/json") >= 0) {
+                    return responseObject.content[contentType];
+                }
+            }
+        }
+        return {};
+    }
     static convertPathToCamelCase(path) {
         const pathSegments = path.split(/[./{]/);
         const camelCaseSegments = pathSegments.map((segment) => {
@@ -320,7 +347,7 @@ class Utils {
         }
         return newStr;
     }
-    static checkServerUrl(servers) {
+    static checkServerUrl(servers, allowHttp = false) {
         const errors = [];
         let serverUrl;
         try {
@@ -343,8 +370,7 @@ class Utils {
                 data: servers,
             });
         }
-        else if (protocol !== "https:") {
-            // Http server url is not supported
+        else if (protocol !== "https:" && !(protocol === "http:" && allowHttp)) {
             const protocolString = protocol.slice(0, -1);
             errors.push({
                 type: ErrorType.UrlProtocolNotSupported,
@@ -360,10 +386,11 @@ class Utils {
         let hasTopLevelServers = false;
         let hasPathLevelServers = false;
         let hasOperationLevelServers = false;
+        const allowHttp = options.projectType === ProjectType.Copilot;
         if (spec.servers && spec.servers.length >= 1) {
             hasTopLevelServers = true;
             // for multiple server, we only use the first url
-            const serverErrors = Utils.checkServerUrl(spec.servers);
+            const serverErrors = Utils.checkServerUrl(spec.servers, allowHttp);
             errors.push(...serverErrors);
         }
         const paths = spec.paths;
@@ -371,7 +398,7 @@ class Utils {
             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);
+                const serverErrors = Utils.checkServerUrl(methods.servers, allowHttp);
                 errors.push(...serverErrors);
             }
             for (const method in methods) {
@@ -379,7 +406,7 @@ class Utils {
                 if (((_a = options.allowMethods) === null || _a === void 0 ? void 0 : _a.includes(method)) && operationObject) {
                     if ((operationObject === null || operationObject === void 0 ? void 0 : operationObject.servers) && operationObject.servers.length >= 1) {
                         hasOperationLevelServers = true;
-                        const serverErrors = Utils.checkServerUrl(operationObject.servers);
+                        const serverErrors = Utils.checkServerUrl(operationObject.servers, allowHttp);
                         errors.push(...serverErrors);
                     }
                 }
@@ -426,7 +453,7 @@ class Utils {
                 optionalParams.push(parameter);
             }
         }
-        else if (schema.type === "object") {
+        else if (Utils.isObjectSchema(schema)) {
             const { properties } = schema;
             for (const property in properties) {
                 let isRequired = false;
@@ -540,29 +567,6 @@ class Utils {
         const serverUrl = operationServer || methodServer || rootServer;
         return serverUrl;
     }
-    static limitACBodyProperties(body, maxCount) {
-        const result = [];
-        let currentCount = 0;
-        for (const element of body) {
-            if (element.type === ConstantString.ContainerType) {
-                const items = this.limitACBodyProperties(element.items, maxCount - currentCount);
-                result.push({
-                    type: ConstantString.ContainerType,
-                    $data: element.$data,
-                    items: items,
-                });
-                currentCount += items.length;
-            }
-            else {
-                result.push(element);
-                currentCount++;
-            }
-            if (currentCount >= maxCount) {
-                break;
-            }
-        }
-        return result;
-    }
 }
 
 // Copyright (c) Microsoft Corporation.
@@ -691,22 +695,6 @@ class Validator {
         }
         return result;
     }
-    validateResponse(method, path) {
-        const result = { isValid: true, reason: [] };
-        const operationObject = this.spec.paths[path][method];
-        const { json, multipleMediaType } = Utils.getResponseJson(operationObject);
-        if (this.options.projectType === ProjectType.SME) {
-            // only support response body only contains “application/json” content type
-            if (multipleMediaType) {
-                result.reason.push(ErrorType.ResponseContainMultipleMediaTypes);
-            }
-            else if (Object.keys(json).length === 0) {
-                // response body should not be empty
-                result.reason.push(ErrorType.ResponseJsonIsEmpty);
-            }
-        }
-        return result;
-    }
     validateServer(method, path) {
         const result = { isValid: true, reason: [] };
         const serverObj = Utils.getServerObject(this.spec, method, path);
@@ -715,8 +703,8 @@ class Validator {
             result.reason.push(ErrorType.NoServerInformation);
         }
         else {
-            // server url should be absolute url with https protocol
-            const serverValidateResult = Utils.checkServerUrl([serverObj]);
+            const allowHttp = this.projectType === ProjectType.Copilot;
+            const serverValidateResult = Utils.checkServerUrl([serverObj], allowHttp);
             result.reason.push(...serverValidateResult.map((item) => item.type));
         }
         return result;
@@ -739,6 +727,9 @@ class Validator {
                     reason: [ErrorType.MultipleAuthNotSupported],
                 };
             }
+            if (this.projectType === ProjectType.Copilot) {
+                return { isValid: true, reason: [] };
+            }
             for (const auths of authSchemeArray) {
                 if (auths.length === 1) {
                     if ((this.options.allowAPIKeyAuth && Utils.isAPIKeyAuth(auths[0].authScheme)) ||
@@ -751,125 +742,6 @@ class Validator {
         }
         return { isValid: false, reason: [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 === ProjectType.Copilot;
-        if (isCopilot && this.hasNestedObjectInSchema(schema)) {
-            paramResult.isValid = false;
-            paramResult.reason = [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(ErrorType.PostBodyContainsRequiredUnsupportedSchema);
-            }
-        }
-        return paramResult;
-    }
-    checkParamSchema(paramObject) {
-        const paramResult = {
-            requiredNum: 0,
-            optionalNum: 0,
-            isValid: true,
-            reason: [],
-        };
-        if (!paramObject) {
-            return paramResult;
-        }
-        const isCopilot = this.projectType === 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(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(ErrorType.ParamsContainRequiredUnsupportedSchema);
-                }
-                continue;
-            }
-            if (schema.type !== "boolean" &&
-                schema.type !== "string" &&
-                schema.type !== "number" &&
-                schema.type !== "integer") {
-                if (isRequiredWithoutDefault) {
-                    paramResult.isValid = false;
-                    paramResult.reason.push(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;
-    }
-    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.
@@ -879,7 +751,6 @@ class CopilotValidator extends Validator {
         this.projectType = ProjectType.Copilot;
         this.options = options;
         this.spec = spec;
-        this.checkCircularReference();
     }
     validateSpec() {
         const result = { errors: [], warnings: [] };
@@ -905,10 +776,6 @@ class CopilotValidator extends Validator {
         if (!methodAndPathResult.isValid) {
             return methodAndPathResult;
         }
-        const circularReferenceResult = this.validateCircularReference(method, path);
-        if (!circularReferenceResult.isValid) {
-            return circularReferenceResult;
-        }
         const operationObject = this.spec.paths[path][method];
         // validate auth
         const authCheckResult = this.validateAuth(method, path);
@@ -920,24 +787,6 @@ class CopilotValidator extends Validator {
         // 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 (requestJsonBody) {
-            const requestBodySchema = requestJsonBody.schema;
-            if (requestBodySchema.type !== "object") {
-                result.reason.push(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;
         }
@@ -1029,6 +878,108 @@ class SMEValidator extends Validator {
         }
         return result;
     }
+    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(ErrorType.ResponseContainMultipleMediaTypes);
+        }
+        else if (Object.keys(json).length === 0) {
+            // response body should not be empty
+            result.reason.push(ErrorType.ResponseJsonIsEmpty);
+        }
+        return result;
+    }
+    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 === ProjectType.Copilot;
+        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 (Utils.isObjectSchema(schema)) {
+            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(ErrorType.PostBodyContainsRequiredUnsupportedSchema);
+            }
+        }
+        return paramResult;
+    }
+    checkParamSchema(paramObject) {
+        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;
+            const isRequiredWithoutDefault = param.required && schema.default === undefined;
+            if (param.in === "header" || param.in === "cookie") {
+                if (isRequiredWithoutDefault) {
+                    paramResult.isValid = false;
+                    paramResult.reason.push(ErrorType.ParamsContainRequiredUnsupportedSchema);
+                }
+                continue;
+            }
+            if (schema.type !== "boolean" &&
+                schema.type !== "string" &&
+                schema.type !== "number" &&
+                schema.type !== "integer") {
+                if (isRequiredWithoutDefault) {
+                    paramResult.isValid = false;
+                    paramResult.reason.push(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;
+    }
     validateParamCount(postBodyResult, paramResult) {
         const result = { isValid: true, reason: [] };
         const totalRequiredParams = postBodyResult.requiredNum + paramResult.requiredNum;
@@ -1304,20 +1255,157 @@ class SpecParser {
     }
 }
 
+// Copyright (c) Microsoft Corporation.
+class JsonDataGenerator {
+    static generate(schema) {
+        return this.generateMockData(schema);
+    }
+    static generateMockData(schema) {
+        if (this.visitedSchemas.has(schema)) {
+            return null; // Prevent circular reference
+        }
+        this.visitedSchemas.add(schema);
+        let result;
+        if (schema.anyOf) {
+            // Select the first schema in anyOf
+            const selectedSchema = schema.anyOf[0];
+            result = this.generateMockData(selectedSchema);
+        }
+        else if (schema.oneOf) {
+            // Select the first schema in oneOf
+            const selectedSchema = schema.oneOf[0];
+            result = this.generateMockData(selectedSchema);
+        }
+        else if (schema.allOf) {
+            // merge all schemas in allOf
+            result = {};
+            for (const subschema of schema.allOf) {
+                const data = this.generateMockData(subschema);
+                result = Object.assign(Object.assign({}, result), data);
+            }
+        }
+        else {
+            switch (schema.type) {
+                case "string":
+                    if (schema.example !== undefined) {
+                        result = schema.example;
+                    }
+                    else if (schema.format) {
+                        switch (schema.format) {
+                            case "date-time":
+                                result = "2024-11-01T05:25:43.593Z";
+                                break;
+                            case "email":
+                                result = "example@example.com";
+                                break;
+                            case "uuid":
+                                result = "123e4567-e89b-12d3-a456-426614174000";
+                                break;
+                            case "ipv4":
+                                result = "192.168.0.1";
+                                break;
+                            case "ipv6":
+                                result = "2001:0db8:85a3:0000:0000:8a2e:0370:7334";
+                                break;
+                            default:
+                                result = "example string";
+                        }
+                    }
+                    else {
+                        result = "example string";
+                    }
+                    break;
+                case "number":
+                    if (schema.example !== undefined) {
+                        result = schema.example;
+                    }
+                    else if (schema.format) {
+                        switch (schema.format) {
+                            case "float":
+                                result = 3.14;
+                                break;
+                            case "double":
+                                result = 3.14159;
+                                break;
+                            default:
+                                result = 123;
+                        }
+                    }
+                    else {
+                        result = 123;
+                    }
+                    break;
+                case "integer":
+                    if (schema.example !== undefined) {
+                        result = schema.example;
+                    }
+                    else if (schema.format) {
+                        switch (schema.format) {
+                            case "int32":
+                                result = 123456;
+                                break;
+                            case "int64":
+                                result = 123456789;
+                                break;
+                            default:
+                                result = 123;
+                        }
+                    }
+                    else {
+                        result = 123;
+                    }
+                    break;
+                case "boolean":
+                    result = schema.example !== undefined ? schema.example : true;
+                    break;
+                case "array":
+                    result = [this.generateMockData(schema.items)];
+                    break;
+                case "object":
+                    result = {};
+                    if (schema.properties) {
+                        for (const key in schema.properties) {
+                            result[key] = this.generateMockData(schema.properties[key]);
+                        }
+                    }
+                    break;
+                default:
+                    result = schema.example || null;
+            }
+        }
+        this.visitedSchemas.delete(schema);
+        return result;
+    }
+}
+JsonDataGenerator.visitedSchemas = new Set();
+
 // Copyright (c) Microsoft Corporation.
 class AdaptiveCardGenerator {
-    static generateAdaptiveCard(operationItem, allowMultipleMediaType = false) {
+    static generateAdaptiveCard(operationItem, allowMultipleMediaType = false, maxElementCount = Number.MAX_SAFE_INTEGER) {
         try {
             const { json } = Utils.getResponseJson(operationItem, allowMultipleMediaType);
             let cardBody = [];
+            let jsonData = {};
+            const warnings = [];
+            const operationId = operationItem.operationId;
             let schema = json.schema;
             let jsonPath = "$";
             if (schema && Object.keys(schema).length > 0) {
+                try {
+                    jsonData = JsonDataGenerator.generate(schema);
+                }
+                catch (err) {
+                    warnings.push({
+                        type: WarningType.GenerateJsonDataFailed,
+                        content: Utils.format(ConstantString.GenerateJsonDataFailed, operationId, err.toString()),
+                        data: operationId,
+                    });
+                }
                 jsonPath = AdaptiveCardGenerator.getResponseJsonPathFromSchema(schema);
                 if (jsonPath !== "$") {
                     schema = schema.properties[jsonPath];
                 }
-                cardBody = AdaptiveCardGenerator.generateCardFromResponse(schema, "");
+                cardBody = AdaptiveCardGenerator.generateCardFromResponse(schema, "", "", maxElementCount);
             }
             // if no schema, try to use example value
             if (cardBody.length === 0 && (json.examples || json.example)) {
@@ -1345,16 +1433,20 @@ class AdaptiveCardGenerator {
                 version: ConstantString.AdaptiveCardVersion,
                 body: cardBody,
             };
-            return [fullCard, jsonPath];
+            return [fullCard, jsonPath, jsonData, warnings];
         }
         catch (err) {
             throw new SpecParserError(err.toString(), ErrorType.GenerateAdaptiveCardFailed);
         }
     }
-    static generateCardFromResponse(schema, name, parentArrayName = "") {
+    static generateCardFromResponse(schema, name, parentArrayName = "", maxElementCount = Number.MAX_SAFE_INTEGER, counter = { count: 0 }) {
+        if (counter.count >= maxElementCount) {
+            return [];
+        }
         if (schema.type === "array") {
             // schema.items can be arbitrary object: schema { type: array, items: {} }
             if (Object.keys(schema.items).length === 0) {
+                counter.count++;
                 return [
                     {
                         type: ConstantString.TextBlockType,
@@ -1363,7 +1455,7 @@ class AdaptiveCardGenerator {
                     },
                 ];
             }
-            const obj = AdaptiveCardGenerator.generateCardFromResponse(schema.items, "", name);
+            const obj = AdaptiveCardGenerator.generateCardFromResponse(schema.items, "", name, maxElementCount, counter);
             const template = {
                 type: ConstantString.ContainerType,
                 $data: name ? `\${${name}}` : "${$root}",
@@ -1373,11 +1465,11 @@ class AdaptiveCardGenerator {
             return [template];
         }
         // some schema may not contain type but contain properties
-        if (schema.type === "object" || (!schema.type && schema.properties)) {
+        if (Utils.isObjectSchema(schema)) {
             const { properties } = schema;
             const result = [];
             for (const property in properties) {
-                const obj = AdaptiveCardGenerator.generateCardFromResponse(properties[property], name ? `${name}.${property}` : property, parentArrayName);
+                const obj = AdaptiveCardGenerator.generateCardFromResponse(properties[property], name ? `${name}.${property}` : property, parentArrayName, maxElementCount, counter);
                 result.push(...obj);
             }
             if (schema.additionalProperties) {
@@ -1390,6 +1482,7 @@ class AdaptiveCardGenerator {
             schema.type === "integer" ||
             schema.type === "boolean" ||
             schema.type === "number") {
+            counter.count++;
             if (!AdaptiveCardGenerator.isImageUrlProperty(schema, name, parentArrayName)) {
                 // string in root: "ddd"
                 let text = "result: ${$root}";
@@ -1414,24 +1507,17 @@ class AdaptiveCardGenerator {
                 ];
             }
             else {
-                if (name) {
-                    return [
-                        {
-                            type: "Image",
-                            url: `\${${name}}`,
-                            $when: `\${${name} != null && ${name} != ''}`,
-                        },
-                    ];
-                }
-                else {
-                    return [
-                        {
-                            type: "Image",
-                            url: "${$data}",
-                            $when: "${$data != null && $data != ''}",
-                        },
-                    ];
-                }
+                const url = name ? `\${${name}}` : "${$data}";
+                const condition = name
+                    ? `\${${name} != null && ${name} != ''}`
+                    : "${$data != null && $data != ''}";
+                return [
+                    {
+                        type: "Image",
+                        url,
+                        $when: condition,
+                    },
+                ];
             }
         }
         if (schema.oneOf || schema.anyOf || schema.not || schema.allOf) {
@@ -1441,7 +1527,7 @@ class AdaptiveCardGenerator {
     }
     // Find the first array property in the response schema object with the well-known name
     static getResponseJsonPathFromSchema(schema) {
-        if (schema.type === "object" || (!schema.type && schema.properties)) {
+        if (Utils.isObjectSchema(schema)) {
             const { properties } = schema;
             for (const property in properties) {
                 const schema = properties[property];