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

package/dist/index.esm2017.mjs

@@ -3,9 +3,10 @@ import { ConfidentialClientApplication } from '@azure/msal-node';
 import { createHash } from 'crypto';
 import { Client } from '@microsoft/microsoft-graph-client';
 import { ManagedIdentityCredential } from '@azure/identity';
-import { ActivityTypes, Channels, TeamsInfo, CardFactory, ActionTypes, MessageFactory, StatusCodes, verifyStateOperationName, tokenExchangeOperationName, TurnContext } from 'botbuilder';
+import { ActivityTypes, Channels, TeamsInfo, CardFactory, ActionTypes, MessageFactory, StatusCodes, verifyStateOperationName, tokenExchangeOperationName, TurnContext, BotFrameworkAdapter } from 'botbuilder';
 import { Dialog } from 'botbuilder-dialogs';
 import { v4 } from 'uuid';
+import axios from 'axios';
 import * as path from 'path';
 import * as fs from 'fs';
 
@@ -1387,6 +1388,69 @@ class TeamsBotSsoPrompt extends 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.create({
+        baseURL: apiEndpoint,
+    });
+    instance.interceptors.request.use(async function (config) {
+        return await authProvider.AddAuthenticationInfo(config);
+    });
+    return instance;
+}
+
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT license.
+/**
+ * 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
+     */
+    async AddAuthenticationInfo(config) {
+        const token = await 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.
@@ -1580,8 +1644,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
@@ -1651,47 +1714,55 @@ class CommandResponseMiddleware {
     }
     async onTurn(context, next) {
         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 = await handlers[0].handleCommandReceived(context, commandText);
-                    await 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 = await handler.handleCommandReceived(context, message);
+                        await context.sendActivity(response);
+                        break;
+                    }
                 }
                 break;
         }
         await next();
     }
     classifyActivity(activity) {
-        if (this.isCommandReceived(activity)) {
-            return ActivityType.CommandReceived;
+        if (activity.type === 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;
@@ -1706,6 +1777,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
@@ -2126,40 +2245,22 @@ class TeamsBotInstallation {
      * @beta
      */
     async members() {
-        let teamsMembers = [];
+        const members = [];
         await this.adapter.continueConversation(this.conversationReference, async (context) => {
-            teamsMembers = await TeamsInfo.getMembers(context);
+            let continuationToken;
+            do {
+                const pagedMembers = await 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
  */
@@ -2226,59 +2327,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 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);
         }
     }
 }
@@ -2437,5 +2562,5 @@ class MessageBuilder {
     }
 }
 
-export { AppCredential, Channel, CommandBot, ErrorCode, ErrorWithCode, IdentityType, LogLevel, Member, MessageBuilder, MsGraphAuthProvider, NotificationBot, OnBehalfOfUserCredential, TeamsBotInstallation, TeamsBotSsoPrompt, TeamsFx, TeamsUserCredential, createMicrosoftGraphClient, getLogLevel, getTediousConnectionConfig, sendAdaptiveCard, sendMessage, setLogFunction, setLogLevel, setLogger };
+export { AppCredential, BearerTokenAuthProvider, Channel, CommandBot, ConversationBot, ErrorCode, ErrorWithCode, IdentityType, LogLevel, Member, MessageBuilder, MsGraphAuthProvider, NotificationBot, OnBehalfOfUserCredential, TeamsBotInstallation, TeamsBotSsoPrompt, TeamsFx, TeamsUserCredential, createApiClient, createMicrosoftGraphClient, getLogLevel, getTediousConnectionConfig, sendAdaptiveCard, sendMessage, setLogFunction, setLogLevel, setLogger };
 //# sourceMappingURL=index.esm2017.mjs.map