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

package/dist/index.esm2017.mjs

@@ -47,6 +47,7 @@ var ErrorType;
     ErrorType["UrlPathNotExist"] = "url-path-not-exist";
     ErrorType["Cancelled"] = "cancelled";
     ErrorType["Unknown"] = "unknown";
+    ErrorType["AddAuthFailed"] = "add-auth-failed";
 })(ErrorType || (ErrorType = {}));
 /**
  * An enum that represents the types of warnings that can occur during validation.
@@ -77,7 +78,12 @@ var ProjectType;
     ProjectType[ProjectType["Copilot"] = 0] = "Copilot";
     ProjectType[ProjectType["SME"] = 1] = "SME";
     ProjectType[ProjectType["TeamsAi"] = 2] = "TeamsAi";
-})(ProjectType || (ProjectType = {}));
+})(ProjectType || (ProjectType = {}));
+var AdaptiveCardUpdateStrategy;
+(function (AdaptiveCardUpdateStrategy) {
+    AdaptiveCardUpdateStrategy[AdaptiveCardUpdateStrategy["CreateNew"] = 0] = "CreateNew";
+    AdaptiveCardUpdateStrategy[AdaptiveCardUpdateStrategy["KeepExisting"] = 1] = "KeepExisting";
+})(AdaptiveCardUpdateStrategy || (AdaptiveCardUpdateStrategy = {}));
 
 // Copyright (c) Microsoft Corporation.
 class ConstantString {
@@ -103,8 +109,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";
@@ -578,6 +584,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.
@@ -1722,8 +1757,8 @@ class ManifestUpdater {
         }
         const appName = this.removeEnvs(manifest.name.short);
         const specRelativePath = ManifestUpdater.getRelativePath(manifestPath, outputSpecPath);
-        const [apiPlugin, warnings] = await ManifestUpdater.generatePluginManifestSchema(spec, specRelativePath, apiPluginFilePath, appName, authMap, options, existingPluginManifestInfo);
-        return [manifest, apiPlugin, warnings];
+        const [apiPlugin, warnings, jsonDataSet] = await ManifestUpdater.generatePluginManifestSchema(spec, specRelativePath, apiPluginFilePath, appName, authMap, options, existingPluginManifestInfo);
+        return [manifest, apiPlugin, warnings, jsonDataSet];
     }
     static updateManifestDescription(manifest, spec) {
         var _a, _b;
@@ -1749,6 +1784,7 @@ class ManifestUpdater {
         const warnings = [];
         const functions = [];
         const functionNamesMap = {};
+        const jsonDataSet = {};
         const conversationStarters = [];
         const paths = spec.paths;
         for (const pathUrl in paths) {
@@ -1780,11 +1816,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) {
@@ -1956,7 +1998,7 @@ class ManifestUpdater {
                     .map((text) => ({ text }));
             }
         }
-        return [apiPlugin, warnings];
+        return [apiPlugin, warnings, jsonDataSet];
     }
     static async updateManifest(manifestPath, outputSpecPath, spec, options, adaptiveCardFolder, authInfo) {
         try {
@@ -2191,6 +2233,39 @@ class SpecParser {
     async listSupportedAPIInfo() {
         throw new Error("Method not implemented.");
     }
+    async addAuthScheme(authName, authType, authParameters, signal) {
+        try {
+            await this.loadSpec();
+            const spec = this.spec;
+            if (signal === null || signal === void 0 ? void 0 : signal.aborted) {
+                throw new SpecParserError(ConstantString.CancelledMessage, 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]: [] }];
+                    }
+                }
+            }
+            await this.saveFilterSpec(this.pathOrSpec, this.spec);
+        }
+        catch (err) {
+            if (err instanceof SpecParserError) {
+                throw err;
+            }
+            throw new SpecParserError(err.toString(), 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}']
@@ -2217,6 +2292,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 {
@@ -2300,7 +2377,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.
      */
-    async generateForCopilot(manifestPath, filter, outputSpecPath, pluginFilePath, existingPluginFilePath, signal) {
+    async generateForCopilot(manifestPath, filter, outputSpecPath, pluginFilePath, existingPluginFilePath, signal, adaptiveCardUpdateStrategy) {
         const result = {
             allSuccess: true,
             warnings: [],
@@ -2345,7 +2422,8 @@ class SpecParser {
                 }
                 : undefined;
             const authMap = Utils.getAuthMap(newSpec);
-            const [updatedManifest, apiPlugin, warnings] = await ManifestUpdater.updateManifestWithAiPlugin(manifestPath, outputSpecPath, pluginFilePath, newSpec, this.options, authMap, existingPluginManifestInfo);
+            const [updatedManifest, apiPlugin, warnings, jsonDataSet] = await ManifestUpdater.updateManifestWithAiPlugin(manifestPath, outputSpecPath, pluginFilePath, newSpec, this.options, authMap, existingPluginManifestInfo);
+            await this.separateAdaptiveCards(apiPlugin, pluginFilePath, jsonDataSet, adaptiveCardUpdateStrategy);
             result.warnings.push(...warnings);
             await fs.outputJSON(manifestPath, updatedManifest, { spaces: 4 });
             await fs.outputJSON(pluginFilePath, apiPlugin, { spaces: 4 });
@@ -2434,6 +2512,7 @@ class SpecParser {
         const newSpecs = await this.getFilteredSpecs(filter, signal);
         const newSpec = newSpecs[1];
         const apiPlugin = (await fs.readJSON(pluginFilePath));
+        const jsonDataSet = {};
         const paths = newSpec.paths;
         for (const pathUrl in paths) {
             const pathItem = paths[pathUrl];
@@ -2451,7 +2530,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,
@@ -2466,8 +2551,44 @@ class SpecParser {
                 }
             }
         }
+        await this.separateAdaptiveCards(apiPlugin, pluginFilePath, jsonDataSet);
         await fs.outputJSON(pluginFilePath, apiPlugin, { spaces: 4 });
     }
+    async separateAdaptiveCards(apiPlugin, pluginFilePath, jsonDataSet = {}, adaptiveCardUpdateStrategy) {
+        var _a, _b;
+        const functions = apiPlugin.functions;
+        if (!adaptiveCardUpdateStrategy) {
+            adaptiveCardUpdateStrategy = AdaptiveCardUpdateStrategy.CreateNew;
+        }
+        if (functions) {
+            const adaptiveCardFolder = path.join(path.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 === AdaptiveCardUpdateStrategy.CreateNew) {
+                            cardName = this.findUniqueCardName(func.name, adaptiveCardFolder);
+                        }
+                        else {
+                            if (adaptiveCardUpdateStrategy === AdaptiveCardUpdateStrategy.KeepExisting &&
+                                fs.existsSync(path.join(adaptiveCardFolder, `${cardName}.json`))) {
+                                responseSemantic.static_template = { file: `adaptiveCards/${cardName}.json` };
+                                continue;
+                            }
+                        }
+                        const cardPath = path.join(adaptiveCardFolder, `${cardName}.json`);
+                        const dataPath = path.join(adaptiveCardFolder, `${cardName}.data.json`);
+                        responseSemantic.static_template = { file: `adaptiveCards/${cardName}.json` };
+                        await fs.outputJSON(cardPath, card, { spaces: 4 });
+                        const data = (_b = jsonDataSet[cardName]) !== null && _b !== void 0 ? _b : {};
+                        await fs.outputJSON(dataPath, data, { spaces: 4 });
+                    }
+                }
+            }
+        }
+    }
     async loadSpec() {
         if (!this.spec) {
             const spec = (await this.parser.parse(this.pathOrSpec));
@@ -2510,7 +2631,19 @@ class SpecParser {
         const specResolved = Utils.resolveEnv(specString);
         return JSON.parse(specResolved);
     }
+    findUniqueCardName(defaultName, cardFolder) {
+        let cardName = defaultName;
+        let counter = 1;
+        while (true) {
+            if (!fs.existsSync(path.join(cardFolder, cardName + ".json"))) {
+                break;
+            }
+            cardName = `${defaultName}${counter}`;
+            counter++;
+        }
+        return cardName;
+    }
 }
 
-export { AdaptiveCardGenerator, ConstantString, ErrorType, ProjectType, SpecParser, SpecParserError, Utils, ValidationStatus, WarningType };
+export { AdaptiveCardGenerator, AdaptiveCardUpdateStrategy, ConstantString, ErrorType, ProjectType, SpecParser, SpecParserError, Utils, ValidationStatus, WarningType };
 //# sourceMappingURL=index.esm2017.mjs.map