@microsoft/m365-spec-parser 0.2.2 → 0.2.3-alpha.07f6df81c.0

package/dist/index.node.cjs.js

@@ -103,6 +103,8 @@ exports.WarningType = void 0;
     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["GenerateJsonDataFailed"] = "generate-json-data-failed";
     WarningType["Unknown"] = "unknown";
 })(exports.WarningType || (exports.WarningType = {}));
 /**
@@ -140,8 +142,10 @@ 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.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";
@@ -236,16 +240,19 @@ class SpecParserError extends Error {
 // Copyright (c) Microsoft Corporation.
 class Utils {
     static hasNestedObjectInSchema(schema) {
-        if (schema.type === "object") {
+        if (this.isObjectSchema(schema)) {
             for (const property in schema.properties) {
                 const nestedSchema = schema.properties[property];
-                if (nestedSchema.type === "object") {
+                if (this.isObjectSchema(nestedSchema)) {
                     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;
     }
@@ -474,7 +481,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;
@@ -588,29 +595,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.
@@ -812,7 +796,7 @@ class Validator {
         }
         const isRequiredWithoutDefault = isRequired && schema.default === undefined;
         const isCopilot = this.projectType === exports.ProjectType.Copilot;
-        if (isCopilot && this.hasNestedObjectInSchema(schema)) {
+        if (isCopilot && Utils.hasNestedObjectInSchema(schema)) {
             paramResult.isValid = false;
             paramResult.reason = [exports.ErrorType.RequestBodyContainsNestedObject];
             return paramResult;
@@ -828,7 +812,7 @@ class Validator {
                 paramResult.optionalNum = paramResult.optionalNum + 1;
             }
         }
-        else if (schema.type === "object") {
+        else if (Utils.isObjectSchema(schema)) {
             const { properties } = schema;
             for (const property in properties) {
                 let isRequired = false;
@@ -864,7 +848,7 @@ class Validator {
         for (let i = 0; i < paramObject.length; i++) {
             const param = paramObject[i];
             const schema = param.schema;
-            if (isCopilot && this.hasNestedObjectInSchema(schema)) {
+            if (isCopilot && Utils.hasNestedObjectInSchema(schema)) {
                 paramResult.isValid = false;
                 paramResult.reason.push(exports.ErrorType.ParamsContainsNestedObject);
                 continue;
@@ -907,17 +891,6 @@ class Validator {
         }
         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.
@@ -976,7 +949,7 @@ class CopilotValidator extends Validator {
         const requestJsonBody = requestBody === null || requestBody === void 0 ? void 0 : requestBody.content["application/json"];
         if (requestJsonBody) {
             const requestBodySchema = requestJsonBody.schema;
-            if (requestBodySchema.type !== "object") {
+            if (!Utils.isObjectSchema(requestBodySchema)) {
                 result.reason.push(exports.ErrorType.PostBodySchemaIsNotJson);
             }
             const requestBodyParamResult = this.checkPostBodySchema(requestBodySchema, requestBody.required);
@@ -1354,20 +1327,157 @@ class SpecFilter {
     }
 }
 
+// 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: exports.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)) {
@@ -1395,16 +1505,20 @@ class AdaptiveCardGenerator {
                 version: ConstantString.AdaptiveCardVersion,
                 body: cardBody,
             };
-            return [fullCard, jsonPath];
+            return [fullCard, jsonPath, jsonData, warnings];
         }
         catch (err) {
             throw new SpecParserError(err.toString(), exports.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,
@@ -1413,7 +1527,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}",
@@ -1423,11 +1537,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) {
@@ -1440,6 +1554,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}";
@@ -1464,24 +1579,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) {
@@ -1491,7 +1599,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];
@@ -1746,7 +1854,7 @@ class ManifestUpdater {
                                 if (requestBody) {
                                     const requestJsonBody = requestBody.content["application/json"];
                                     const requestBodySchema = requestJsonBody.schema;
-                                    if (requestBodySchema.type === "object") {
+                                    if (Utils.isObjectSchema(requestBodySchema)) {
                                         for (const property in requestBodySchema.properties) {
                                             const schema = requestBodySchema.properties[property];
                                             ManifestUpdater.checkSchema(schema, method, pathUrl);
@@ -1774,8 +1882,7 @@ class ManifestUpdater {
                                     try {
                                         const { json } = Utils.getResponseJson(operationItem);
                                         if (json.schema) {
-                                            const [card, jsonPath] = AdaptiveCardGenerator.generateAdaptiveCard(operationItem);
-                                            card.body = Utils.limitACBodyProperties(card.body, 5);
+                                            const [card, jsonPath] = AdaptiveCardGenerator.generateAdaptiveCard(operationItem, false, 5);
                                             const responseSemantic = wrapResponseSemantics(card, jsonPath);
                                             funcObj.capabilities = {
                                                 response_semantics: responseSemantic,
@@ -2250,6 +2357,24 @@ class SpecParser {
                 const newUnResolvedSpec = newSpecs[0];
                 const newSpec = newSpecs[1];
                 const authInfo = Utils.getAuthInfo(newSpec);
+                const paths = newUnResolvedSpec.paths;
+                for (const pathUrl in paths) {
+                    const operations = paths[pathUrl];
+                    for (const method in operations) {
+                        const operationItem = operations[method];
+                        const operationId = operationItem.operationId;
+                        const containsSpecialCharacters = /[^a-zA-Z0-9_]/.test(operationId);
+                        if (!containsSpecialCharacters) {
+                            continue;
+                        }
+                        operationItem.operationId = operationId.replace(/[^a-zA-Z0-9]/g, "_");
+                        result.warnings.push({
+                            type: exports.WarningType.OperationIdContainsSpecialCharacters,
+                            content: Utils.format(ConstantString.OperationIdContainsSpecialCharacters, operationId, operationItem.operationId),
+                            data: operationId,
+                        });
+                    }
+                }
                 yield this.saveFilterSpec(outputSpecPath, newUnResolvedSpec);
                 if (signal === null || signal === void 0 ? void 0 : signal.aborted) {
                     throw new SpecParserError(ConstantString.CancelledMessage, exports.ErrorType.Cancelled);
@@ -2303,13 +2428,14 @@ class SpecParser {
                             if (this.options.allowMethods.includes(method)) {
                                 const operation = newSpec.paths[url][method];
                                 try {
-                                    const [card, jsonPath] = AdaptiveCardGenerator.generateAdaptiveCard(operation);
+                                    const [card, jsonPath, jsonData, warnings] = AdaptiveCardGenerator.generateAdaptiveCard(operation);
+                                    result.warnings.push(...warnings);
                                     const safeAdaptiveCardName = operation.operationId.replace(/[^a-zA-Z0-9]/g, "_");
                                     const fileName = path__default['default'].join(adaptiveCardFolder, `${safeAdaptiveCardName}.json`);
                                     const wrappedCard = wrapAdaptiveCard(card, jsonPath);
                                     yield fs__default['default'].outputJSON(fileName, wrappedCard, { spaces: 2 });
                                     const dataFileName = path__default['default'].join(adaptiveCardFolder, `${safeAdaptiveCardName}.data.json`);
-                                    yield fs__default['default'].outputJSON(dataFileName, {}, { spaces: 2 });
+                                    yield fs__default['default'].outputJSON(dataFileName, jsonData, { spaces: 2 });
                                 }
                                 catch (err) {
                                     result.allSuccess = false;