Allow command handlers to match regexes

src/App.spec.ts

@@ -1110,6 +1110,9 @@ describe('App', () => {
           app.command('/echo', async ({}) => {
             /* noop */
           });
+          app.command(/\/e.*/, async ({}) => {
+            /* noop */
+          });
 
           // invalid view constraints
           const invalidViewConstraints1 = ({
@@ -1256,6 +1259,110 @@ describe('App', () => {
         });
       });
 
+      describe('command()', () => {
+        it('should respond to exact name matches', async () => {
+          // Arrange
+          const overrides = buildOverrides([withNoopWebClient()]);
+          const App = await importApp(overrides); // eslint-disable-line  @typescript-eslint/naming-convention, no-underscore-dangle, id-blacklist, id-match
+          let matchCount = 0;
+
+          // Act
+          const app = new App({ receiver: fakeReceiver, authorize: sinon.fake.resolves(dummyAuthorizationResult) });
+          app.command('/hello', async () => {
+            ++matchCount;
+          });
+          await fakeReceiver.sendEvent({
+            body: {
+              type: 'slash_command',
+              command: '/hello',
+            },
+            ack: noop,
+          });
+
+          // Assert
+          assert.equal(matchCount, 1);
+        });
+
+        it('should respond to pattern matches', async () => {
+          // Arrange
+          const overrides = buildOverrides([withNoopWebClient()]);
+          const App = await importApp(overrides); // eslint-disable-line  @typescript-eslint/naming-convention, no-underscore-dangle, id-blacklist, id-match
+          let matchCount = 0;
+
+          // Act
+          const app = new App({ receiver: fakeReceiver, authorize: sinon.fake.resolves(dummyAuthorizationResult) });
+          app.command(/h.*/, async () => {
+            ++matchCount;
+          });
+          await fakeReceiver.sendEvent({
+            body: {
+              type: 'slash_command',
+              command: '/hello',
+            },
+            ack: noop,
+          });
+
+          // Assert
+          assert.equal(matchCount, 1);
+        });
+
+        it('should run all matching listeners', async () => {
+          // Arrange
+          const overrides = buildOverrides([withNoopWebClient()]);
+          const App = await importApp(overrides); // eslint-disable-line  @typescript-eslint/naming-convention, no-underscore-dangle, id-blacklist, id-match
+          let firstCount = 0;
+          let secondCount = 0;
+
+          // Act
+          const app = new App({ receiver: fakeReceiver, authorize: sinon.fake.resolves(dummyAuthorizationResult) });
+          app.command(/h.*/, async () => {
+            ++firstCount;
+          });
+          app.command(/he.*/, async () => {
+            ++secondCount;
+          });
+          await fakeReceiver.sendEvent({
+            body: {
+              type: 'slash_command',
+              command: '/hello',
+            },
+            ack: noop,
+          });
+
+          // Assert
+          assert.equal(firstCount, 1);
+          assert.equal(secondCount, 1);
+        });
+
+        it('should not stop at an unsuccessful match', async () => {
+          // Arrange
+          const overrides = buildOverrides([withNoopWebClient()]);
+          const App = await importApp(overrides); // eslint-disable-line  @typescript-eslint/naming-convention, no-underscore-dangle, id-blacklist, id-match
+          let firstCount = 0;
+          let secondCount = 0;
+
+          // Act
+          const app = new App({ receiver: fakeReceiver, authorize: sinon.fake.resolves(dummyAuthorizationResult) });
+          app.command(/x.*/, async () => {
+            ++firstCount;
+          });
+          app.command(/h.*/, async () => {
+            ++secondCount;
+          });
+          await fakeReceiver.sendEvent({
+            body: {
+              type: 'slash_command',
+              command: '/hello',
+            },
+            ack: noop,
+          });
+
+          // Assert
+          assert.equal(firstCount, 0);
+          assert.equal(secondCount, 1);
+        });
+      });
+
       describe('respond()', () => {
         it('should respond to events with a response_url', async () => {
           // Arrange

src/App.ts

@@ -528,8 +528,7 @@ export default class App {
     this.listeners.push([onlyActions, matchConstraints(constraints), ...listeners] as Middleware<AnyMiddlewareArgs>[]);
   }
 
-  // TODO: should command names also be regex?
-  public command(commandName: string, ...listeners: Middleware<SlackCommandMiddlewareArgs>[]): void {
+  public command(commandName: string | RegExp, ...listeners: Middleware<SlackCommandMiddlewareArgs>[]): void {
     this.listeners.push([onlyCommands, matchCommandName(commandName), ...listeners] as Middleware<AnyMiddlewareArgs>[]);
   }
 

src/middleware/builtin.spec.ts

@@ -510,12 +510,18 @@ describe('matchCommandName', () => {
     };
   }
 
-  it('should detect valid requests', async () => {
+  it('should detect requests that match exactly', async () => {
     const fakeNext = sinon.fake();
     await matchCommandName('/hi')(buildArgs(fakeNext));
     assert.isTrue(fakeNext.called);
   });
 
+  it('should detect requests that match a pattern', async () => {
+    const fakeNext = sinon.fake();
+    await matchCommandName(/h/)(buildArgs(fakeNext));
+    assert.isTrue(fakeNext.called);
+  });
+
   it('should skip other requests', async () => {
     const fakeNext = sinon.fake();
     await matchCommandName('/hello')(buildArgs(fakeNext));

src/middleware/builtin.ts

@@ -241,12 +241,12 @@ export function matchMessage(
 }
 
 /**
- * Middleware that filters out any command that doesn't match name
+ * Middleware that filters out any command that doesn't match the pattern
  */
-export function matchCommandName(name: string): Middleware<SlackCommandMiddlewareArgs> {
+export function matchCommandName(pattern: string | RegExp): Middleware<SlackCommandMiddlewareArgs> {
   return async ({ command, next }) => {
-    // Filter out any commands that are not the correct command name
-    if (name !== command.command) {
+    // Filter out any commands that do not match the correct command name or pattern
+    if (!matchesPattern(pattern, command.command)) {
       return;
     }
 
@@ -255,6 +255,13 @@ export function matchCommandName(name: string): Middleware<SlackCommandMiddlewar
   };
 }
 
+function matchesPattern(pattern: string | RegExp, candidate: string): boolean {
+  if (typeof pattern === 'string') {
+    return pattern === candidate;
+  }
+  return pattern.test(candidate);
+}
+
 /*
  * Middleware that filters out events that don't match pattern
  */