@microsoft/m365-spec-parser 0.2.6-alpha.d99d3c39d.0 → 0.2.6-alpha.dea29f186.0

package/dist/index.node.cjs.js

@@ -89,6 +89,7 @@ exports.ErrorType = void 0;
     ErrorType["UrlPathNotExist"] = "url-path-not-exist";
     ErrorType["Cancelled"] = "cancelled";
     ErrorType["Unknown"] = "unknown";
+    ErrorType["AddAuthFailed"] = "add-auth-failed";
 })(exports.ErrorType || (exports.ErrorType = {}));
 /**
  * An enum that represents the types of warnings that can occur during validation.
@@ -119,7 +120,12 @@ exports.ProjectType = void 0;
     ProjectType[ProjectType["Copilot"] = 0] = "Copilot";
     ProjectType[ProjectType["SME"] = 1] = "SME";
     ProjectType[ProjectType["TeamsAi"] = 2] = "TeamsAi";
-})(exports.ProjectType || (exports.ProjectType = {}));
+})(exports.ProjectType || (exports.ProjectType = {}));
+exports.AdaptiveCardUpdateStrategy = void 0;
+(function (AdaptiveCardUpdateStrategy) {
+    AdaptiveCardUpdateStrategy[AdaptiveCardUpdateStrategy["CreateNew"] = 0] = "CreateNew";
+    AdaptiveCardUpdateStrategy[AdaptiveCardUpdateStrategy["KeepExisting"] = 1] = "KeepExisting";
+})(exports.AdaptiveCardUpdateStrategy || (exports.AdaptiveCardUpdateStrategy = {}));
 
 // Copyright (c) Microsoft Corporation.
 class ConstantString {
@@ -145,8 +151,8 @@ ConstantString.AuthTypeIsNotSupported = "Unsupported authorization type in API '
 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.WrappedCardVersion = "1.0";
+ConstantString.WrappedCardSchema = "https://developer.microsoft.com/json-schemas/teams/v1.19/MicrosoftTeams.ResponseRenderingTemplate.schema.json";
 ConstantString.WrappedCardResponseLayout = "list";
 ConstantString.GetMethod = "get";
 ConstantString.PostMethod = "post";
@@ -620,6 +626,35 @@ class Utils {
         const serverUrl = operationServer || methodServer || rootServer;
         return serverUrl;
     }
+    static getAuthSchemaObject(authType, authParameters) {
+        switch (authType) {
+            case "oauth":
+            case "microsoft-entra":
+                return {
+                    type: "oauth2",
+                    flows: {
+                        authorizationCode: {
+                            authorizationUrl: authParameters.authorizationUrl,
+                            tokenUrl: authParameters.tokenUrl,
+                            refreshUrl: authParameters.refreshUrl,
+                            scopes: authParameters.scopes,
+                        },
+                    },
+                };
+            case "api-key":
+                return {
+                    type: "apiKey",
+                    in: authParameters.in,
+                    name: authParameters.name,
+                };
+            case "bearer-token":
+            default:
+                return {
+                    type: "http",
+                    scheme: "bearer",
+                };
+        }
+    }
 }
 
 // Copyright (c) Microsoft Corporation.
@@ -1765,8 +1800,8 @@ class ManifestUpdater {
             }
             const appName = this.removeEnvs(manifest.name.short);
             const specRelativePath = ManifestUpdater.getRelativePath(manifestPath, outputSpecPath);
-            const [apiPlugin, warnings] = yield ManifestUpdater.generatePluginManifestSchema(spec, specRelativePath, apiPluginFilePath, appName, authMap, options, existingPluginManifestInfo);
-            return [manifest, apiPlugin, warnings];
+            const [apiPlugin, warnings, jsonDataSet] = yield ManifestUpdater.generatePluginManifestSchema(spec, specRelativePath, apiPluginFilePath, appName, authMap, options, existingPluginManifestInfo);
+            return [manifest, apiPlugin, warnings, jsonDataSet];
         });
     }
     static updateManifestDescription(manifest, spec) {
@@ -1794,6 +1829,7 @@ class ManifestUpdater {
             const warnings = [];
             const functions = [];
             const functionNamesMap = {};
+            const jsonDataSet = {};
             const conversationStarters = [];
             const paths = spec.paths;
             for (const pathUrl in paths) {
@@ -1825,11 +1861,17 @@ class ManifestUpdater {
                                     try {
                                         const { json } = Utils.getResponseJson(operationItem);
                                         if (json.schema) {
-                                            const [card, jsonPath] = AdaptiveCardGenerator.generateAdaptiveCard(operationItem, false, 5);
+                                            const [card, jsonPath, jsonData] = AdaptiveCardGenerator.generateAdaptiveCard(operationItem, false, 5);
                                             const responseSemantic = wrapResponseSemantics(card, jsonPath);
                                             funcObj.capabilities = {
                                                 response_semantics: responseSemantic,
                                             };
+                                            if (jsonPath === "$") {
+                                                jsonDataSet[safeFunctionName] = jsonData;
+                                            }
+                                            else {
+                                                jsonDataSet[safeFunctionName] = jsonData[jsonPath];
+                                            }
                                         }
                                     }
                                     catch (err) {
@@ -2001,7 +2043,7 @@ class ManifestUpdater {
                         .map((text) => ({ text }));
                 }
             }
-            return [apiPlugin, warnings];
+            return [apiPlugin, warnings, jsonDataSet];
         });
     }
     static updateManifest(manifestPath, outputSpecPath, spec, options, adaptiveCardFolder, authInfo) {
@@ -2245,6 +2287,41 @@ class SpecParser {
             throw new Error("Method not implemented.");
         });
     }
+    addAuthScheme(authName, authType, authParameters, signal) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                yield this.loadSpec();
+                const spec = this.spec;
+                if (signal === null || signal === void 0 ? void 0 : signal.aborted) {
+                    throw new SpecParserError(ConstantString.CancelledMessage, exports.ErrorType.Cancelled);
+                }
+                if (!spec.components) {
+                    spec.components = {};
+                }
+                if (!spec.components.securitySchemes) {
+                    spec.components.securitySchemes = {};
+                }
+                spec.components.securitySchemes[authName] = Utils.getAuthSchemaObject(authType, authParameters);
+                const paths = spec.paths;
+                for (const path in paths) {
+                    const methods = paths[path];
+                    for (const method in methods) {
+                        const operationId = methods[method].operationId;
+                        if (authParameters.apis.includes(operationId)) {
+                            methods[method].security = [{ [authName]: [] }];
+                        }
+                    }
+                }
+                yield this.saveFilterSpec(this.pathOrSpec, this.spec);
+            }
+            catch (err) {
+                if (err instanceof SpecParserError) {
+                    throw err;
+                }
+                throw new SpecParserError(err.toString(), exports.ErrorType.AddAuthFailed);
+            }
+        });
+    }
     /**
      * 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}']
@@ -2272,6 +2349,8 @@ class SpecParser {
                         operationId: operationId,
                         isValid: isValid,
                         reason: reason,
+                        description: operation.description,
+                        summary: operation.summary,
                     };
                     // Try best to parse server url and auth type
                     try {
@@ -2360,7 +2439,7 @@ class SpecParser {
      * @param outputSpecPath File path of the new OpenAPI specification file to generate. If not specified or empty, no spec file will be generated.
      * @param pluginFilePath File path of the api plugin file to generate.
      */
-    generateForCopilot(manifestPath, filter, outputSpecPath, pluginFilePath, existingPluginFilePath, signal) {
+    generateForCopilot(manifestPath, filter, outputSpecPath, pluginFilePath, existingPluginFilePath, signal, adaptiveCardUpdateStrategy) {
         return __awaiter(this, void 0, void 0, function* () {
             const result = {
                 allSuccess: true,
@@ -2406,7 +2485,8 @@ class SpecParser {
                     }
                     : undefined;
                 const authMap = Utils.getAuthMap(newSpec);
-                const [updatedManifest, apiPlugin, warnings] = yield ManifestUpdater.updateManifestWithAiPlugin(manifestPath, outputSpecPath, pluginFilePath, newSpec, this.options, authMap, existingPluginManifestInfo);
+                const [updatedManifest, apiPlugin, warnings, jsonDataSet] = yield ManifestUpdater.updateManifestWithAiPlugin(manifestPath, outputSpecPath, pluginFilePath, newSpec, this.options, authMap, existingPluginManifestInfo);
+                yield this.separateAdaptiveCards(apiPlugin, pluginFilePath, jsonDataSet, adaptiveCardUpdateStrategy);
                 result.warnings.push(...warnings);
                 yield fs__default['default'].outputJSON(manifestPath, updatedManifest, { spaces: 4 });
                 yield fs__default['default'].outputJSON(pluginFilePath, apiPlugin, { spaces: 4 });
@@ -2499,6 +2579,7 @@ class SpecParser {
             const newSpecs = yield this.getFilteredSpecs(filter, signal);
             const newSpec = newSpecs[1];
             const apiPlugin = (yield fs__default['default'].readJSON(pluginFilePath));
+            const jsonDataSet = {};
             const paths = newSpec.paths;
             for (const pathUrl in paths) {
                 const pathItem = paths[pathUrl];
@@ -2516,7 +2597,13 @@ class SpecParser {
                                     }
                                     const { json } = Utils.getResponseJson(operationItem);
                                     if (json.schema) {
-                                        const [card, jsonPath] = AdaptiveCardGenerator.generateAdaptiveCard(operationItem, false, 5);
+                                        const [card, jsonPath, jsonData] = AdaptiveCardGenerator.generateAdaptiveCard(operationItem, false, 5);
+                                        if (jsonPath === "$") {
+                                            jsonDataSet[safeFunctionName] = jsonData;
+                                        }
+                                        else {
+                                            jsonDataSet[safeFunctionName] = jsonData[jsonPath];
+                                        }
                                         const responseSemantic = wrapResponseSemantics(card, jsonPath);
                                         apiPlugin.functions.find((func) => func.name === safeFunctionName).capabilities = {
                                             response_semantics: responseSemantic,
@@ -2531,9 +2618,47 @@ class SpecParser {
                     }
                 }
             }
+            yield this.separateAdaptiveCards(apiPlugin, pluginFilePath, jsonDataSet);
             yield fs__default['default'].outputJSON(pluginFilePath, apiPlugin, { spaces: 4 });
         });
     }
+    separateAdaptiveCards(apiPlugin, pluginFilePath, jsonDataSet = {}, adaptiveCardUpdateStrategy) {
+        var _a, _b;
+        return __awaiter(this, void 0, void 0, function* () {
+            const functions = apiPlugin.functions;
+            if (!adaptiveCardUpdateStrategy) {
+                adaptiveCardUpdateStrategy = exports.AdaptiveCardUpdateStrategy.CreateNew;
+            }
+            if (functions) {
+                const adaptiveCardFolder = path__default['default'].join(path__default['default'].dirname(pluginFilePath), "adaptiveCards");
+                for (const func of functions) {
+                    if ((_a = func.capabilities) === null || _a === void 0 ? void 0 : _a.response_semantics) {
+                        const responseSemantic = func.capabilities.response_semantics;
+                        const card = responseSemantic.static_template;
+                        if (card && Object.keys(card).length !== 0) {
+                            let cardName = func.name;
+                            if (adaptiveCardUpdateStrategy === exports.AdaptiveCardUpdateStrategy.CreateNew) {
+                                cardName = this.findUniqueCardName(func.name, adaptiveCardFolder);
+                            }
+                            else {
+                                if (adaptiveCardUpdateStrategy === exports.AdaptiveCardUpdateStrategy.KeepExisting &&
+                                    fs__default['default'].existsSync(path__default['default'].join(adaptiveCardFolder, `${cardName}.json`))) {
+                                    responseSemantic.static_template = { file: `adaptiveCards/${cardName}.json` };
+                                    continue;
+                                }
+                            }
+                            const cardPath = path__default['default'].join(adaptiveCardFolder, `${cardName}.json`);
+                            const dataPath = path__default['default'].join(adaptiveCardFolder, `${cardName}.data.json`);
+                            responseSemantic.static_template = { file: `adaptiveCards/${cardName}.json` };
+                            yield fs__default['default'].outputJSON(cardPath, card, { spaces: 4 });
+                            const data = (_b = jsonDataSet[cardName]) !== null && _b !== void 0 ? _b : {};
+                            yield fs__default['default'].outputJSON(dataPath, data, { spaces: 4 });
+                        }
+                    }
+                }
+            }
+        });
+    }
     loadSpec() {
         return __awaiter(this, void 0, void 0, function* () {
             if (!this.spec) {
@@ -2580,6 +2705,18 @@ class SpecParser {
         const specResolved = Utils.resolveEnv(specString);
         return JSON.parse(specResolved);
     }
+    findUniqueCardName(defaultName, cardFolder) {
+        let cardName = defaultName;
+        let counter = 1;
+        while (true) {
+            if (!fs__default['default'].existsSync(path__default['default'].join(cardFolder, cardName + ".json"))) {
+                break;
+            }
+            cardName = `${defaultName}${counter}`;
+            counter++;
+        }
+        return cardName;
+    }
 }
 
 exports.AdaptiveCardGenerator = AdaptiveCardGenerator;