@microsoft/m365-spec-parser 0.2.1 → 0.2.2-alpha.070ff93c3.0

package/dist/index.node.cjs.js

@@ -59,10 +59,12 @@ exports.ErrorType = void 0;
     ErrorType["RelativeServerUrlNotSupported"] = "relative-server-url-not-supported";
     ErrorType["NoSupportedApi"] = "no-supported-api";
     ErrorType["NoExtraAPICanBeAdded"] = "no-extra-api-can-be-added";
+    ErrorType["AddedAPINotInOriginalSpec"] = "added-api-not-in-original-spec";
     ErrorType["ResolveServerUrlFailed"] = "resolve-server-url-failed";
     ErrorType["SwaggerNotSupported"] = "swagger-not-supported";
     ErrorType["MultipleAuthNotSupported"] = "multiple-auth-not-supported";
     ErrorType["SpecVersionNotSupported"] = "spec-version-not-supported";
+    ErrorType["CircularReferenceNotSupported"] = "circular-reference-not-supported";
     ErrorType["ListFailed"] = "list-failed";
     ErrorType["listSupportedAPIInfoFailed"] = "list-supported-api-info-failed";
     ErrorType["FilterSpecFailed"] = "filter-spec-failed";
@@ -299,21 +301,28 @@ class Utils {
     static updateFirstLetter(str) {
         return str.charAt(0).toUpperCase() + str.slice(1);
     }
-    static getResponseJson(operationObject) {
-        var _a, _b;
+    static getResponseJson(operationObject, allowMultipleMediaType = false) {
+        var _a;
         let json = {};
         let multipleMediaType = false;
         for (const code of ConstantString.ResponseCodeFor20X) {
             const responseObject = (_a = operationObject === null || operationObject === void 0 ? void 0 : operationObject.responses) === null || _a === void 0 ? void 0 : _a[code];
-            if ((_b = responseObject === null || responseObject === void 0 ? void 0 : responseObject.content) === null || _b === void 0 ? void 0 : _b["application/json"]) {
-                multipleMediaType = false;
-                json = responseObject.content["application/json"];
-                if (Utils.containMultipleMediaTypes(responseObject)) {
-                    multipleMediaType = true;
-                    json = {};
-                }
-                else {
-                    break;
+            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 };
+                        }
+                    }
                 }
             }
         }
@@ -574,10 +583,46 @@ 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.
 class Validator {
+    constructor() {
+        this.hasCircularReference = false;
+    }
+    checkCircularReference() {
+        try {
+            JSON.stringify(this.spec);
+        }
+        catch (e) {
+            if (e.message.includes("Converting circular structure to JSON")) {
+                this.hasCircularReference = true;
+            }
+        }
+    }
     listAPIs() {
         var _a;
         if (this.apiMap) {
@@ -673,6 +718,22 @@ class Validator {
         }
         return result;
     }
+    validateCircularReference(method, path) {
+        const result = { isValid: true, reason: [] };
+        if (this.hasCircularReference) {
+            const operationObject = this.spec.paths[path][method];
+            try {
+                JSON.stringify(operationObject);
+            }
+            catch (e) {
+                if (e.message.includes("Converting circular structure to JSON")) {
+                    result.isValid = false;
+                    result.reason.push(exports.ErrorType.CircularReferenceNotSupported);
+                }
+            }
+        }
+        return result;
+    }
     validateResponse(method, path) {
         const result = { isValid: true, reason: [] };
         const operationObject = this.spec.paths[path][method];
@@ -861,6 +922,7 @@ class CopilotValidator extends Validator {
         this.projectType = exports.ProjectType.Copilot;
         this.options = options;
         this.spec = spec;
+        this.checkCircularReference();
     }
     validateSpec() {
         const result = { errors: [], warnings: [] };
@@ -886,6 +948,10 @@ 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);
@@ -929,6 +995,7 @@ class SMEValidator extends Validator {
         this.projectType = exports.ProjectType.SME;
         this.options = options;
         this.spec = spec;
+        this.checkCircularReference();
     }
     validateSpec() {
         const result = { errors: [], warnings: [] };
@@ -956,6 +1023,10 @@ class SMEValidator 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);
@@ -1026,6 +1097,7 @@ class TeamsAIValidator extends Validator {
         this.projectType = exports.ProjectType.TeamsAi;
         this.options = options;
         this.spec = spec;
+        this.checkCircularReference();
     }
     validateSpec() {
         const result = { errors: [], warnings: [] };
@@ -1045,6 +1117,10 @@ class TeamsAIValidator 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 operationId
         if (!this.options.allowMissingId && !operationObject.operationId) {
@@ -1077,6 +1153,161 @@ class ValidatorFactory {
     }
 }
 
+// Copyright (c) Microsoft Corporation.
+class SpecOptimizer {
+    static optimize(spec, options) {
+        const mergedOptions = Object.assign(Object.assign({}, SpecOptimizer.defaultOptions), (options !== null && options !== void 0 ? options : {}));
+        const newSpec = JSON.parse(JSON.stringify(spec));
+        if (mergedOptions.removeUserDefinedRootProperty) {
+            SpecOptimizer.removeUserDefinedRootProperty(newSpec);
+        }
+        if (mergedOptions.removeUnusedComponents) {
+            SpecOptimizer.removeUnusedComponents(newSpec);
+        }
+        if (mergedOptions.removeUnusedTags) {
+            SpecOptimizer.removeUnusedTags(newSpec);
+        }
+        if (mergedOptions.removeUnusedSecuritySchemas) {
+            SpecOptimizer.removeUnusedSecuritySchemas(newSpec);
+        }
+        return newSpec;
+    }
+    static removeUnusedSecuritySchemas(spec) {
+        if (!spec.components || !spec.components.securitySchemes) {
+            return;
+        }
+        const usedSecuritySchemas = new Set();
+        for (const pathKey in spec.paths) {
+            for (const methodKey in spec.paths[pathKey]) {
+                const operation = spec.paths[pathKey][methodKey];
+                if (operation.security) {
+                    operation.security.forEach((securityReq) => {
+                        for (const schemaKey in securityReq) {
+                            usedSecuritySchemas.add(schemaKey);
+                        }
+                    });
+                }
+            }
+        }
+        if (spec.security) {
+            spec.security.forEach((securityReq) => {
+                for (const schemaKey in securityReq) {
+                    usedSecuritySchemas.add(schemaKey);
+                }
+            });
+        }
+        for (const schemaKey in spec.components.securitySchemes) {
+            if (!usedSecuritySchemas.has(schemaKey)) {
+                delete spec.components.securitySchemes[schemaKey];
+            }
+        }
+        if (Object.keys(spec.components.securitySchemes).length === 0) {
+            delete spec.components.securitySchemes;
+        }
+        if (Object.keys(spec.components).length === 0) {
+            delete spec.components;
+        }
+    }
+    static removeUnusedTags(spec) {
+        if (!spec.tags) {
+            return;
+        }
+        const usedTags = new Set();
+        for (const pathKey in spec.paths) {
+            for (const methodKey in spec.paths[pathKey]) {
+                const operation = spec.paths[pathKey][methodKey];
+                if (operation.tags) {
+                    operation.tags.forEach((tag) => usedTags.add(tag));
+                }
+            }
+        }
+        spec.tags = spec.tags.filter((tagObj) => usedTags.has(tagObj.name));
+    }
+    static removeUserDefinedRootProperty(spec) {
+        for (const key in spec) {
+            if (key.startsWith("x-")) {
+                delete spec[key];
+            }
+        }
+    }
+    static removeUnusedComponents(spec) {
+        const components = spec.components;
+        if (!components) {
+            return;
+        }
+        delete spec.components;
+        const usedComponentsSet = new Set();
+        const specString = JSON.stringify(spec);
+        const componentReferences = SpecOptimizer.getComponentReferences(specString);
+        for (const reference of componentReferences) {
+            this.addComponent(reference, usedComponentsSet, components);
+        }
+        const newComponents = {};
+        for (const componentName of usedComponentsSet) {
+            const parts = componentName.split("/");
+            const component = this.getComponent(componentName, components);
+            if (component) {
+                let current = newComponents;
+                for (let i = 2; i < parts.length; i++) {
+                    if (i === parts.length - 1) {
+                        current[parts[i]] = component;
+                    }
+                    else if (!current[parts[i]]) {
+                        current[parts[i]] = {};
+                    }
+                    current = current[parts[i]];
+                }
+            }
+        }
+        // securitySchemes are referenced directly by name, to void issue, just keep them all and use removeUnusedSecuritySchemas to remove unused ones
+        if (components.securitySchemes) {
+            newComponents.securitySchemes = components.securitySchemes;
+        }
+        if (Object.keys(newComponents).length !== 0) {
+            spec.components = newComponents;
+        }
+    }
+    static getComponentReferences(specString) {
+        const matches = Array.from(specString.matchAll(/['"](#\/components\/.+?)['"]/g));
+        const matchResult = matches.map((match) => match[1]);
+        return matchResult;
+    }
+    static getComponent(componentPath, components) {
+        const parts = componentPath.split("/");
+        let current = components;
+        for (const part of parts) {
+            if (part === "#" || part === "components") {
+                continue;
+            }
+            current = current[part];
+            if (!current) {
+                return null;
+            }
+        }
+        return current;
+    }
+    static addComponent(componentName, usedComponentsSet, components) {
+        if (usedComponentsSet.has(componentName)) {
+            return;
+        }
+        usedComponentsSet.add(componentName);
+        const component = this.getComponent(componentName, components);
+        if (component) {
+            const componentString = JSON.stringify(component);
+            const componentReferences = SpecOptimizer.getComponentReferences(componentString);
+            for (const reference of componentReferences) {
+                this.addComponent(reference, usedComponentsSet, components);
+            }
+        }
+    }
+}
+SpecOptimizer.defaultOptions = {
+    removeUnusedComponents: true,
+    removeUnusedTags: true,
+    removeUserDefinedRootProperty: true,
+    removeUnusedSecuritySchemas: true,
+};
+
 // Copyright (c) Microsoft Corporation.
 class SpecFilter {
     static specFilter(filter, unResolveSpec, resolvedSpec, options) {
@@ -1110,7 +1341,7 @@ class SpecFilter {
                 }
             }
             newSpec.paths = newPaths;
-            return newSpec;
+            return SpecOptimizer.optimize(newSpec);
         }
         catch (err) {
             throw new SpecParserError(err.toString(), exports.ErrorType.FilterSpecFailed);
@@ -1120,9 +1351,9 @@ class SpecFilter {
 
 // Copyright (c) Microsoft Corporation.
 class AdaptiveCardGenerator {
-    static generateAdaptiveCard(operationItem) {
+    static generateAdaptiveCard(operationItem, allowMultipleMediaType = false) {
         try {
-            const { json } = Utils.getResponseJson(operationItem);
+            const { json } = Utils.getResponseJson(operationItem, allowMultipleMediaType);
             let cardBody = [];
             let schema = json.schema;
             let jsonPath = "$";
@@ -1233,7 +1464,7 @@ class AdaptiveCardGenerator {
                         {
                             type: "Image",
                             url: `\${${name}}`,
-                            $when: `\${${name} != null}`,
+                            $when: `\${${name} != null && ${name} != ''}`,
                         },
                     ];
                 }
@@ -1242,7 +1473,7 @@ class AdaptiveCardGenerator {
                         {
                             type: "Image",
                             url: "${$data}",
-                            $when: "${$data != null}",
+                            $when: "${$data != null && $data != ''}",
                         },
                     ];
                 }
@@ -1335,7 +1566,7 @@ function inferPreviewCardTemplate(card) {
         result.image = {
             url: `\${${inferredProperties.imageUrl}}`,
             alt: `\${if(${inferredProperties.imageUrl}, ${inferredProperties.imageUrl}, 'N/A')}`,
-            $when: `\${${inferredProperties.imageUrl} != null}`,
+            $when: `\${${inferredProperties.imageUrl} != null && ${inferredProperties.imageUrl} != ''}`,
         };
     }
     return result;
@@ -1480,6 +1711,7 @@ class ManifestUpdater {
                             const confirmationBodies = [];
                             if (operationItem) {
                                 const operationId = operationItem.operationId;
+                                const safeFunctionName = operationId.replace(/[^a-zA-Z0-9]/g, "_");
                                 const description = (_a = operationItem.description) !== null && _a !== void 0 ? _a : "";
                                 const summary = operationItem.summary;
                                 const paramObject = operationItem.parameters;
@@ -1507,7 +1739,7 @@ class ManifestUpdater {
                                     }
                                 }
                                 const funcObj = {
-                                    name: operationId,
+                                    name: safeFunctionName,
                                     description: description,
                                 };
                                 if (options.allowResponseSemantics) {
@@ -1515,7 +1747,7 @@ class ManifestUpdater {
                                         const { json } = Utils.getResponseJson(operationItem);
                                         if (json.schema) {
                                             const [card, jsonPath] = AdaptiveCardGenerator.generateAdaptiveCard(operationItem);
-                                            card.body = card.body.slice(0, 5);
+                                            card.body = Utils.limitACBodyProperties(card.body, 5);
                                             const responseSemantic = wrapResponseSemantics(card, jsonPath);
                                             funcObj.capabilities = {
                                                 response_semantics: responseSemantic,
@@ -1543,7 +1775,7 @@ class ManifestUpdater {
                                     }
                                 }
                                 functions.push(funcObj);
-                                functionNames.push(operationId);
+                                functionNames.push(safeFunctionName);
                                 const conversationStarterStr = (summary !== null && summary !== void 0 ? summary : description).slice(0, ConstantString.ConversationStarterMaxLens);
                                 if (conversationStarterStr) {
                                     conversationStarters.push(conversationStarterStr);
@@ -1643,7 +1875,6 @@ class ManifestUpdater {
                         const auth = authInfo.authScheme;
                         const safeRegistrationIdName = Utils.getSafeRegistrationIdEnvName(`${authInfo.name}_${ConstantString.RegistrationIdPostfix[authInfo.authScheme.type]}`);
                         if (Utils.isAPIKeyAuth(auth) || Utils.isBearerTokenAuth(auth)) {
-                            const safeApiSecretRegistrationId = Utils.getSafeRegistrationIdEnvName(`${authInfo.name}_${ConstantString.RegistrationIdPostfix[authInfo.authScheme.type]}`);
                             composeExtension.authorization = {
                                 authType: "apiSecretServiceAuth",
                                 apiSecretServiceAuthConfiguration: {
@@ -1652,16 +1883,13 @@ class ManifestUpdater {
                             };
                         }
                         else if (Utils.isOAuthWithAuthCodeFlow(auth)) {
+                            // TODO: below schema is coming from design doc, may need to update when shcema is finalized
                             composeExtension.authorization = {
                                 authType: "oAuth2.0",
                                 oAuthConfiguration: {
                                     oauthConfigurationId: `\${{${safeRegistrationIdName}}}`,
                                 },
                             };
-                            updatedPart.webApplicationInfo = {
-                                id: "${{AAD_APP_CLIENT_ID}}",
-                                resource: "api://${{DOMAIN}}/${{AAD_APP_CLIENT_ID}}",
-                            };
                         }
                     }
                     updatedPart.composeExtensions = [composeExtension];
@@ -1699,12 +1927,17 @@ class ManifestUpdater {
                                         command.parameters = command.parameters.filter((param) => param.isRequired);
                                     }
                                     else if (command.parameters && command.parameters.length > 0) {
-                                        command.parameters = [command.parameters[0]];
-                                        warnings.push({
-                                            type: exports.WarningType.OperationOnlyContainsOptionalParam,
-                                            content: Utils.format(ConstantString.OperationOnlyContainsOptionalParam, command.id),
-                                            data: command.id,
-                                        });
+                                        if (command.parameters.length > 1) {
+                                            command.parameters = [command.parameters[0]];
+                                            warnings.push({
+                                                type: exports.WarningType.OperationOnlyContainsOptionalParam,
+                                                content: Utils.format(ConstantString.OperationOnlyContainsOptionalParam, command.id),
+                                                data: {
+                                                    commandId: command.id,
+                                                    parameterName: command.parameters[0].name,
+                                                },
+                                            });
+                                        }
                                     }
                                     if (adaptiveCardFolder) {
                                         const adaptiveCardPath = path__default['default'].join(adaptiveCardFolder, command.id + ".json");
@@ -1782,7 +2015,13 @@ class SpecParser {
             try {
                 try {
                     yield this.loadSpec();
-                    yield this.parser.validate(this.spec);
+                    if (!this.parser.$refs.circular) {
+                        yield this.parser.validate(this.spec);
+                    }
+                    else {
+                        const clonedUnResolveSpec = JSON.parse(JSON.stringify(this.unResolveSpec));
+                        yield this.parser.validate(clonedUnResolveSpec);
+                    }
                 }
                 catch (e) {
                     return {
@@ -1874,19 +2113,36 @@ class SpecParser {
                         isValid: isValid,
                         reason: reason,
                     };
-                    if (isValid) {
+                    // Try best to parse server url and auth type
+                    try {
                         const serverObj = Utils.getServerObject(spec, method.toLocaleLowerCase(), path);
                         if (serverObj) {
-                            apiResult.server = Utils.resolveEnv(serverObj.url);
+                            apiResult.server = serverObj.url;
                         }
+                    }
+                    catch (err) {
+                        // ignore
+                    }
+                    try {
                         const authArray = Utils.getAuthArray(operation.security, spec);
-                        for (const auths of authArray) {
-                            if (auths.length === 1) {
-                                apiResult.auth = auths[0];
-                                break;
+                        if (authArray.length !== 0) {
+                            for (const auths of authArray) {
+                                if (auths.length === 1) {
+                                    apiResult.auth = auths[0];
+                                    break;
+                                }
+                                else {
+                                    apiResult.auth = {
+                                        authScheme: { type: "multipleAuth" },
+                                        name: auths.map((auth) => auth.name).join(", "),
+                                    };
+                                }
                             }
                         }
                     }
+                    catch (err) {
+                        // ignore
+                    }
                     result.APIs.push(apiResult);
                 }
                 result.allAPICount = result.APIs.length;
@@ -1919,7 +2175,8 @@ class SpecParser {
                 if (signal === null || signal === void 0 ? void 0 : signal.aborted) {
                     throw new SpecParserError(ConstantString.CancelledMessage, exports.ErrorType.Cancelled);
                 }
-                const newSpec = (yield this.parser.dereference(newUnResolvedSpec));
+                const clonedUnResolveSpec = JSON.parse(JSON.stringify(newUnResolvedSpec));
+                const newSpec = (yield this.parser.dereference(clonedUnResolveSpec));
                 return [newUnResolvedSpec, newSpec];
             }
             catch (err) {
@@ -1996,10 +2253,11 @@ class SpecParser {
                                 const operation = newSpec.paths[url][method];
                                 try {
                                     const [card, jsonPath] = AdaptiveCardGenerator.generateAdaptiveCard(operation);
-                                    const fileName = path__default['default'].join(adaptiveCardFolder, `${operation.operationId}.json`);
+                                    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, `${operation.operationId}.data.json`);
+                                    const dataFileName = path__default['default'].join(adaptiveCardFolder, `${safeAdaptiveCardName}.data.json`);
                                     yield fs__default['default'].outputJSON(dataFileName, {}, { spaces: 2 });
                                 }
                                 catch (err) {
@@ -2033,7 +2291,8 @@ class SpecParser {
     loadSpec() {
         return __awaiter(this, void 0, void 0, function* () {
             if (!this.spec) {
-                this.unResolveSpec = (yield this.parser.parse(this.pathOrSpec));
+                const spec = (yield this.parser.parse(this.pathOrSpec));
+                this.unResolveSpec = this.resolveEnvForSpec(spec);
                 // Convert swagger 2.0 to openapi 3.0
                 if (!this.unResolveSpec.openapi && this.unResolveSpec.swagger === "2.0") {
                     const specObj = yield converter__default['default'].convert(this.unResolveSpec, {});
@@ -2070,6 +2329,11 @@ class SpecParser {
             yield fs__default['default'].outputFile(outputSpecPath, resultStr);
         });
     }
+    resolveEnvForSpec(spec) {
+        const specString = JSON.stringify(spec);
+        const specResolved = Utils.resolveEnv(specString);
+        return JSON.parse(specResolved);
+    }
 }
 
 exports.AdaptiveCardGenerator = AdaptiveCardGenerator;