@microsoft/teamsfx 0.6.2-alpha.444739e17.0 → 0.6.2-alpha.52f41e8aa.0

package/dist/index.node.cjs.js

@@ -11,6 +11,7 @@ var identity = require('@azure/identity');
 var botbuilder = require('botbuilder');
 var botbuilderDialogs = require('botbuilder-dialogs');
 var uuid = require('uuid');
+var axios = require('axios');
 var path = require('path');
 var fs = require('fs');
 
@@ -35,6 +36,7 @@ function _interopNamespace(e) {
 }
 
 var jwt_decode__default = /*#__PURE__*/_interopDefaultLegacy(jwt_decode);
+var axios__default = /*#__PURE__*/_interopDefaultLegacy(axios);
 var path__namespace = /*#__PURE__*/_interopNamespace(path);
 var fs__namespace = /*#__PURE__*/_interopNamespace(fs);
 
@@ -1438,6 +1440,72 @@ class TeamsBotSsoPrompt extends botbuilderDialogs.Dialog {
     }
 }
 
+// Copyright (c) Microsoft Corporation.
+/**
+ * Initializes new Axios instance with specific auth provider
+ *
+ * @param apiEndpoint - Base url of the API
+ * @param authProvider - Auth provider that injects authentication info to each request
+ * @returns axios instance configured with specfic auth provider
+ *
+ * @example
+ * ```typescript
+ * const client = createApiClient("https://my-api-endpoint-base-url", new BasicAuthProvider("xxx","xxx"));
+ * ```
+ *
+ * @beta
+ */
+function createApiClient(apiEndpoint, authProvider) {
+    // Add a request interceptor
+    const instance = axios__default["default"].create({
+        baseURL: apiEndpoint,
+    });
+    instance.interceptors.request.use(function (config) {
+        return tslib.__awaiter(this, void 0, void 0, function* () {
+            return yield authProvider.AddAuthenticationInfo(config);
+        });
+    });
+    return instance;
+}
+
+// Copyright (c) Microsoft Corporation.
+/**
+ * Provider that handles Bearer Token authentication
+ *
+ * @beta
+ */
+class BearerTokenAuthProvider {
+    /**
+     * @param getToken Function that returns the content of bearer token used in http request
+     *
+     * @beta
+     */
+    constructor(getToken) {
+        this.getToken = getToken;
+    }
+    /**
+     * Adds authentication info to http requests
+     *
+     * @param config - Contains all the request information and can be updated to include extra authentication info.
+     * Refer https://axios-http.com/docs/req_config for detailed document.
+     *
+     * @beta
+     */
+    AddAuthenticationInfo(config) {
+        return tslib.__awaiter(this, void 0, void 0, function* () {
+            const token = yield this.getToken();
+            if (!config.headers) {
+                config.headers = {};
+            }
+            if (config.headers["Authorization"]) {
+                throw new Error("Authorization header already exists!");
+            }
+            config.headers["Authorization"] = `Bearer ${token}`;
+            return config;
+        });
+    }
+}
+
 // Copyright (c) Microsoft Corporation.
 /**
  * A class providing credential and configuration.
@@ -1635,8 +1703,7 @@ var ActivityType;
     ActivityType[ActivityType["CurrentBotUninstalled"] = 2] = "CurrentBotUninstalled";
     ActivityType[ActivityType["TeamDeleted"] = 3] = "TeamDeleted";
     ActivityType[ActivityType["TeamRestored"] = 4] = "TeamRestored";
-    ActivityType[ActivityType["CommandReceived"] = 5] = "CommandReceived";
-    ActivityType[ActivityType["Unknown"] = 6] = "Unknown";
+    ActivityType[ActivityType["Unknown"] = 5] = "Unknown";
 })(ActivityType || (ActivityType = {}));
 /**
  * @internal
@@ -1709,15 +1776,23 @@ class CommandResponseMiddleware {
     onTurn(context, next) {
         return tslib.__awaiter(this, void 0, void 0, function* () {
             const type = this.classifyActivity(context.activity);
-            let handlers = [];
             switch (type) {
-                case ActivityType.CommandReceived:
+                case ActivityType.CurrentBotMessaged:
                     // Invoke corresponding command handler for the command response
                     const commandText = this.getActivityText(context.activity);
-                    handlers = this.filterCommandHandler(commandText, this.commandHandlers);
-                    if (handlers.length > 0) {
-                        const response = yield handlers[0].handleCommandReceived(context, commandText);
-                        yield context.sendActivity(response);
+                    const message = {
+                        text: commandText,
+                    };
+                    for (const handler of this.commandHandlers) {
+                        const matchResult = this.shouldTrigger(handler.triggerPatterns, commandText);
+                        // It is important to note that the command bot will stop processing handlers
+                        // when the first command handler is matched.
+                        if (!!matchResult) {
+                            message.matches = Array.isArray(matchResult) ? matchResult : void 0;
+                            const response = yield handler.handleCommandReceived(context, message);
+                            yield context.sendActivity(response);
+                            break;
+                        }
                     }
                     break;
             }
@@ -1725,32 +1800,32 @@ class CommandResponseMiddleware {
         });
     }
     classifyActivity(activity) {
-        if (this.isCommandReceived(activity)) {
-            return ActivityType.CommandReceived;
+        if (activity.type === botbuilder.ActivityTypes.Message) {
+            return ActivityType.CurrentBotMessaged;
         }
         return ActivityType.Unknown;
     }
-    isCommandReceived(activity) {
-        if (this.commandHandlers) {
-            const commandText = this.getActivityText(activity);
-            const handlers = this.filterCommandHandler(commandText, this.commandHandlers);
-            return handlers.length > 0;
-        }
-        else {
-            return false;
-        }
-    }
-    filterCommandHandler(commandText, commandHandlers) {
-        const handlers = commandHandlers.filter((handler) => {
-            var _a;
-            if (typeof handler.commandNameOrPattern === "string") {
-                return handler.commandNameOrPattern.toLocaleLowerCase() === commandText;
+    matchPattern(pattern, text) {
+        if (text) {
+            if (typeof pattern === "string") {
+                const regExp = new RegExp(pattern, "i");
+                return regExp.test(text);
             }
-            else {
-                return (_a = handler.commandNameOrPattern) === null || _a === void 0 ? void 0 : _a.test(commandText);
+            if (pattern instanceof RegExp) {
+                const matches = text.match(pattern);
+                return matches !== null && matches !== void 0 ? matches : false;
             }
-        });
-        return handlers;
+        }
+        return false;
+    }
+    shouldTrigger(patterns, text) {
+        const expressions = Array.isArray(patterns) ? patterns : [patterns];
+        for (const ex of expressions) {
+            const arg = this.matchPattern(ex, text);
+            if (arg)
+                return arg;
+        }
+        return false;
     }
     getActivityText(activity) {
         let text = activity.text;
@@ -1765,6 +1840,54 @@ class CommandResponseMiddleware {
     }
 }
 
+// Copyright (c) Microsoft Corporation.
+/**
+ * A command bot for receiving commands and sending responses in Teams.
+ *
+ * @remarks
+ * Ensure each command should ONLY be registered with the command once, otherwise it'll cause unexpected behavior if you register the same command more than once.
+ *
+ * @beta
+ */
+class CommandBot {
+    /**
+     * Creates a new instance of the `CommandBot`.
+     *
+     * @param adapter The bound `BotFrameworkAdapter`.
+     * @param options - initialize options
+     *
+     * @beta
+     */
+    constructor(adapter, options) {
+        this.middleware = new CommandResponseMiddleware(options === null || options === void 0 ? void 0 : options.commands);
+        this.adapter = adapter.use(this.middleware);
+    }
+    /**
+     * Registers a command into the command bot.
+     *
+     * @param command The command to registered.
+     *
+     * @beta
+     */
+    registerCommand(command) {
+        if (command) {
+            this.middleware.commandHandlers.push(command);
+        }
+    }
+    /**
+     * Registers commands into the command bot.
+     *
+     * @param commands The command to registered.
+     *
+     * @beta
+     */
+    registerCommands(commands) {
+        if (commands) {
+            this.middleware.commandHandlers.push(...commands);
+        }
+    }
+}
+
 // Copyright (c) Microsoft Corporation.
 /**
  * @internal
@@ -2208,41 +2331,23 @@ class TeamsBotInstallation {
      */
     members() {
         return tslib.__awaiter(this, void 0, void 0, function* () {
-            let teamsMembers = [];
+            const members = [];
             yield this.adapter.continueConversation(this.conversationReference, (context) => tslib.__awaiter(this, void 0, void 0, function* () {
-                teamsMembers = yield botbuilder.TeamsInfo.getMembers(context);
+                let continuationToken;
+                do {
+                    const pagedMembers = yield botbuilder.TeamsInfo.getPagedMembers(context, undefined, continuationToken);
+                    continuationToken = pagedMembers.continuationToken;
+                    for (const member of pagedMembers.members) {
+                        members.push(new Member(this, member));
+                    }
+                } while (continuationToken !== undefined);
             }));
-            const members = [];
-            for (const member of teamsMembers) {
-                members.push(new Member(this, member));
-            }
             return members;
         });
     }
 }
 /**
- * Provide static utilities for bot conversation, including
- * - send notification to varies targets (e.g., member, channel, incoming wehbook)
- * - handle command and response.
- *
- * @example
- * Here's an example on how to send notification via Teams Bot.
- * ```typescript
- * // initialize (it's recommended to be called before handling any bot message)
- * const notificationBot = new NotificationBot(adapter);
- *
- * // get all bot installations and send message
- * for (const target of await notificationBot.installations()) {
- *   await target.sendMessage("Hello Notification");
- * }
- *
- * // alternative - send message to all members
- * for (const target of await notificationBot.installations()) {
- *   for (const member of await target.members()) {
- *     await member.sendMessage("Hello Notification");
- *   }
- * }
- * ```
+ * Provide utilities to send notification to varies targets (e.g., member, channel, incoming wehbook).
  *
  * @beta
  */
@@ -2311,59 +2416,83 @@ class NotificationBot {
 
 // Copyright (c) Microsoft Corporation.
 /**
- * A command bot for receiving commands and sending responses in Teams.
- *
- * @remarks
- * Ensure each command should ONLY be registered with the command once, otherwise it'll cause unexpected behavior if you register the same command more than once.
+ * Provide utilities for bot conversation, including:
+ *   - handle command and response.
+ *   - send notification to varies targets (e.g., member, channel, incoming wehbook).
  *
  * @example
- * You can register your commands  through the constructor of the {@link CommandBot}, or use the `registerCommand` and `registerCommands` API to add commands after creating the `CommandBot` instance.
+ * For command and response, you can register your commands through the constructor, or use the `registerCommand` and `registerCommands` API to add commands later.
  *
  * ```typescript
  * // register through constructor
- * const commandBot = new CommandBot(adapter, [ new HelloWorldCommandHandler() ]);
+ * const conversationBot = new ConversationBot({
+ *   command: {
+ *     enabled: true,
+ *     options: {
+ *         commands: [ new HelloWorldCommandHandler() ],
+ *     },
+ *   },
+ * });
  *
  * // register through `register*` API
- * commandBot.registerCommand(new HelpCommandHandler());
+ * conversationBot.command.registerCommand(new HelpCommandHandler());
  * ```
  *
+ * For notification, you can enable notification at initialization, then send notificaations at any time.
+ *
+ * ```typescript
+ * // enable through constructor
+ * const conversationBot = new ConversationBot({
+ *   notification: {
+ *     enabled: true,
+ *   },
+ * });
+ *
+ * // get all bot installations and send message
+ * for (const target of await conversationBot.notification.installations()) {
+ *   await target.sendMessage("Hello Notification");
+ * }
+ *
+ * // alternative - send message to all members
+ * for (const target of await conversationBot.notification.installations()) {
+ *   for (const member of await target.members()) {
+ *     await member.sendMessage("Hello Notification");
+ *   }
+ * }
+ * ```
+ *
+ * @remarks
+ * Set `adapter` in {@link ConversationOptions} to use your own bot adapter.
+ *
+ * For command and response, ensure each command should ONLY be registered with the command once, otherwise it'll cause unexpected behavior if you register the same command more than once.
+ *
+ * For notification, set `notification.options.storage` in {@link ConversationOptions} to use your own storage implementation.
+ *
  * @beta
  */
-class CommandBot {
+class ConversationBot {
     /**
-     * Creates a new instance of the `CommandBot`.
-     *
-     * @param adapter The bound `BotFrameworkAdapter`.
-     * @param commands The commands to registered with the command bot. Each command should implement the interface {@link TeamsFxBotCommandHandler} so that it can be correctly handled by this command bot.
-     *
-     * @beta
-     */
-    constructor(adapter, commands) {
-        this.middleware = new CommandResponseMiddleware(commands);
-        this.adapter = adapter.use(this.middleware);
-    }
-    /**
-     * Registers a command into the command bot.
+     * Creates new instance of the `ConversationBot`.
      *
-     * @param command The command to registered.
+     * @param options - initialize options
      *
      * @beta
      */
-    registerCommand(command) {
-        if (command) {
-            this.middleware.commandHandlers.push(command);
+    constructor(options) {
+        if (options.adapter) {
+            this.adapter = options.adapter;
         }
-    }
-    /**
-     * Registers commands into the command bot.
-     *
-     * @param commands The command to registered.
-     *
-     * @beta
-     */
-    registerCommands(commands) {
-        if (commands) {
-            this.middleware.commandHandlers.push(...commands);
+        else {
+            this.adapter = new botbuilder.BotFrameworkAdapter({
+                appId: process.env.BOT_ID,
+                appPassword: process.env.BOT_PASSWORD,
+            });
+        }
+        if (options.command.enabled) {
+            this.command = new CommandBot(this.adapter, options.command.options);
+        }
+        if (options.notification.enabled) {
+            this.notification = new NotificationBot(this.adapter, options.notification.options);
         }
     }
 }
@@ -2523,8 +2652,10 @@ class MessageBuilder {
 }
 
 exports.AppCredential = AppCredential;
+exports.BearerTokenAuthProvider = BearerTokenAuthProvider;
 exports.Channel = Channel;
 exports.CommandBot = CommandBot;
+exports.ConversationBot = ConversationBot;
 exports.ErrorWithCode = ErrorWithCode;
 exports.Member = Member;
 exports.MessageBuilder = MessageBuilder;
@@ -2535,6 +2666,7 @@ exports.TeamsBotInstallation = TeamsBotInstallation;
 exports.TeamsBotSsoPrompt = TeamsBotSsoPrompt;
 exports.TeamsFx = TeamsFx;
 exports.TeamsUserCredential = TeamsUserCredential;
+exports.createApiClient = createApiClient;
 exports.createMicrosoftGraphClient = createMicrosoftGraphClient;
 exports.getLogLevel = getLogLevel;
 exports.getTediousConnectionConfig = getTediousConnectionConfig;