feat: ability to add command w/o handler to cmd menu. refactor: CommandElementals type

src/command-group.ts

@@ -9,7 +9,7 @@ import {
   type LanguageCode,
   Middleware,
 } from "./deps.deno.ts";
-import type { CommandElementals, CommandOptions } from "./types.ts";
+import type { BotCommandX, CommandOptions } from "./types.ts";
 import {
   ensureArray,
   getCommandsRegex,
@@ -34,7 +34,7 @@ export interface SetMyCommandsParams {
    */
   language_code?: LanguageCode;
   /** Commands that can be each one passed to a SetMyCommands Call */
-  commands: BotCommand[];
+  commands: (BotCommand & { noHandler?: boolean })[];
 }
 
 /**
@@ -275,20 +275,21 @@ export class CommandGroup<C extends Context> {
   }
 
   /**
-   * Serialize all register commands into it's name, prefix and language
+   * Serialize all register commands into a more detailed object
+   * including it's name, prefix and language, and more data
    *
    * @param filterLanguage if undefined, it returns all names
    * else get only the locales for the given filterLanguage
    * fallbacks to "default"
    *
-   * @returns an array of {@link CommandElementals}
+   * @returns an array of {@link BotCommandX}
    *
    * Note: mainly used to serialize for {@link FuzzyMatch}
    */
 
   public toElementals(
     filterLanguage?: LanguageCode | "default",
-  ): CommandElementals[] {
+  ): BotCommandX[] {
     this._populateMetadata();
 
     return Array.from(this._scopes.values())
@@ -300,7 +301,7 @@ export class CommandGroup<C extends Context> {
             const [language, local] of command.languages.entries()
           ) {
             elements.push({
-              name: local.name instanceof RegExp
+              command: local.name instanceof RegExp
                 ? local.name.source
                 : local.name,
               language,
@@ -309,6 +310,7 @@ export class CommandGroup<C extends Context> {
               description: command.getLocalizedDescription(
                 language,
               ),
+              ...(command.noHandler ? { noHandler: true } : {}),
             });
           }
           if (filterLanguage) {

src/command.ts

@@ -1,6 +1,5 @@
 import { CommandsFlavor } from "./context.ts";
 import {
-  type BotCommand,
   type BotCommandScope,
   type BotCommandScopeAllChatAdministrators,
   type BotCommandScopeAllGroupChats,
@@ -12,8 +11,9 @@ import {
   type LanguageCode,
   type Middleware,
   type MiddlewareObj,
+  type NextFunction,
 } from "./deps.deno.ts";
-import type { CommandOptions } from "./types.ts";
+import type { BotCommandX, CommandOptions } from "./types.ts";
 import { ensureArray, type MaybeArray } from "./utils/array.ts";
 import {
   isAdmin,
@@ -66,6 +66,7 @@ export class Command<C extends Context = Context> implements MiddlewareObj<C> {
     targetedCommands: "optional",
     ignoreCase: false,
   };
+  private _noHandler: boolean;
 
   /**
    * Initialize a new command with a default handler.
@@ -130,14 +131,17 @@ export class Command<C extends Context = Context> implements MiddlewareObj<C> {
       | Partial<CommandOptions>,
     options?: Partial<CommandOptions>,
   ) {
-    const handler = isMiddleware(handlerOrOptions)
-      ? handlerOrOptions
-      : undefined;
+    let handler = isMiddleware(handlerOrOptions) ? handlerOrOptions : undefined;
 
     options = !handler && isCommandOptions(handlerOrOptions)
       ? handlerOrOptions
       : options;
 
+    if (!handler) {
+      handler = async (_ctx: Context, next: NextFunction) => await next();
+      this._noHandler = true;
+    } else this._noHandler = false;
+
     this._options = { ...this._options, ...options };
     if (this._options.prefix?.trim() === "") this._options.prefix = "/";
     this._languages.set("default", { name: name, description });
@@ -248,6 +252,14 @@ export class Command<C extends Context = Context> implements MiddlewareObj<C> {
     return this._options.prefix;
   }
 
+  /**
+   * Get if this command has a handler
+   */
+
+  get noHandler(): boolean {
+    return this._noHandler;
+  }
+
   /**
    * Registers the command to a scope to allow it to be handled and used with `setMyCommands`.
    * This will automatically apply filtering middlewares for you, so the handler only runs on the specified scope.
@@ -507,13 +519,14 @@ export class Command<C extends Context = Context> implements MiddlewareObj<C> {
    */
   public toObject(
     languageCode: LanguageCode | "default" = "default",
-  ): BotCommand {
+  ): Pick<BotCommandX, "command" | "description" | "noHandler"> {
     const localizedName = this.getLocalizedName(languageCode);
     return {
       command: localizedName instanceof RegExp
         ? localizedName.source
         : localizedName,
       description: this.getLocalizedDescription(languageCode),
+      ...(this.noHandler ? { noHandler: true } : {}),
     };
   }
 

src/context.ts

@@ -123,7 +123,7 @@ export function commands<C extends Context>() {
 
       if (!result || !result.command) return null;
 
-      return result.command.prefix + result.command.name;
+      return result.command.prefix + result.command.command;
     };
 
     ctx.getCommandEntities = (

src/types.ts

@@ -1,4 +1,5 @@
 import type {
+  BotCommand,
   BotCommandScope,
   LanguageCode,
   MessageEntity,
@@ -34,12 +35,24 @@ export interface CommandOptions {
   ignoreCase: boolean;
 }
 
-export interface CommandElementals {
-  name: string;
+/**
+ * BotCommand representation with more information about it.
+ * Specially in regards to the plugin manipulation of it
+ */
+export interface BotCommandX extends BotCommand {
   prefix: string;
+  /**
+   * Language in which this command is localize
+   */
   language: LanguageCode | "default";
+  /**
+   * Scopes in which this command is registered
+   */
   scopes: BotCommandScope[];
-  description: string;
+  /**
+   * True if this command has no middleware attach to it. False if it has.
+   */
+  noHandler?: boolean;
 }
 
 /** represents a bot__command entity inside a text message */

src/utils/jaro-winkler.ts

@@ -1,6 +1,6 @@
 import { CommandGroup } from "../command-group.ts";
 import { Context, LanguageCode } from "../deps.deno.ts";
-import type { CommandElementals } from "../types.ts";
+import type { BotCommandX } from "../types.ts";
 import { LanguageCodes } from "../language-codes.ts";
 
 export function distance(s1: string, s2: string) {
@@ -79,7 +79,7 @@ export type JaroWinklerOptions = {
 };
 
 type CommandSimilarity = {
-  command: CommandElementals | null;
+  command: BotCommandX | null;
   similarity: number;
 };
 
@@ -142,7 +142,7 @@ export function fuzzyMatch<C extends Context>(
 
   const bestMatch = cmds.reduce(
     (best: CommandSimilarity, command) => {
-      const similarity = JaroWinklerDistance(userInput, command.name, {
+      const similarity = JaroWinklerDistance(userInput, command.command, {
         ...options,
       });
       return similarity > best.similarity ? { command, similarity } : best;

test/command-group.test.ts

@@ -4,6 +4,7 @@ import { dummyCtx } from "./context.test.ts";
 import {
   assert,
   assertEquals,
+  assertObjectMatch,
   assertRejects,
   assertThrows,
   describe,
@@ -16,7 +17,15 @@ describe("CommandGroup", () => {
       const commands = new CommandGroup();
       commands.command("test", "no handler");
 
-      assertEquals(commands.toArgs().scopes, []);
+      assertObjectMatch(commands.toArgs().scopes[0], {
+        commands: [
+          {
+            command: "test",
+            description: "no handler",
+            noHandler: true,
+          },
+        ],
+      });
     });
 
     it("should create a command with a default handler", () => {
@@ -125,10 +134,10 @@ describe("CommandGroup", () => {
           },
         ]);
       });
-      it("should omit commands with no handler", () => {
+      it("should mark commands with no handler", () => {
         const commands = new CommandGroup();
         commands.command("test", "handler", (_) => _);
-        commands.command("omitme", "nohandler");
+        commands.command("markme", "nohandler");
         const params = commands.toSingleScopeArgs({
           type: "chat",
           chat_id: 10,
@@ -139,6 +148,11 @@ describe("CommandGroup", () => {
             language_code: undefined,
             commands: [
               { command: "test", description: "handler" },
+              {
+                command: "markme",
+                description: "nohandler",
+                noHandler: true,
+              },
             ],
           },
         ]);

test/integration.test.ts

@@ -96,6 +96,20 @@ describe("Integration", () => {
 
       assertSpyCalls(setMyCommandsSpy, 0);
     });
+    it("should be able to set commands with no handler", async () => {
+      const myCommands = new CommandGroup();
+      myCommands.command("command", "super description");
+
+      const setMyCommandsSpy = spy(resolvesNext([true] as const));
+
+      await myCommands.setCommands({
+        api: {
+          raw: { setMyCommands: setMyCommandsSpy },
+        } as unknown as Api,
+      });
+
+      assertSpyCalls(setMyCommandsSpy, 1);
+    });
   });
 
   describe("ctx.setMyCommands", () => {