Wrapper function to allow creating a command in one shot

[khill-fbmc]

I do like the fluent interface, but I was having issues with prettier formatting my method chains oddly...

This is what I have done to remedy this issue, plus, I am tossing around ideas of a file based command autoloader with the commands being modules..........

Anyways... what do you think about something like this?

import type {
  ArgumentOptions,
  Command,
  HandlerFn,
  OptionOptions
} from "bandersnatch";
import { command as _origCommand } from "bandersnatch";

interface CommandProps<T> {
  command: string;
  description: string;
  opts?: Record<string, OptionOptions>;
  args?: Record<string, ArgumentOptions>;
  action: HandlerFn<T>;
}

export function buildCommand<T>({
  command,
  description,
  args,
  opts,
  action
}: CommandProps<T>): Command {
  const cmd = _origCommand<T>(command, { description });

  if (opts) {
    Object.entries(opts).forEach(([optName, config]) =>
      cmd.option(optName, config)
    );
  }

  if (args) {
    Object.entries(args).forEach(([argName, config]) =>
      cmd.argument(argName, config)
    );
  }

  return cmd.action(action);
}

[khill-fbmc]

It grows!

import type {
  ArgumentOptions,
  Command,
  HandlerFn,
  OptionOptions
} from "bandersnatch";
import { command as _origCommand } from "bandersnatch";

type OptionMap = Record<string, OptionOptions>;
type OptionFn<T extends OptionMap> = (optionMap: T) => T;

type ArgMap = Record<string, ArgumentOptions>;
type ArgFn<T extends ArgMap> = (optionMap: T) => T;

interface BuildCommandArgs<T> {
  command: string;
  description: string;
  hidden?: boolean;
  subCommands?: Command[];
  action?: HandlerFn<T>;
  args?: ArgMap | ArgFn<ArgMap>;
  opts?: OptionMap | OptionFn<OptionMap>;
}

/**
 * @todo get the given `T` to match up options to params
 */
export function buildCommand<T>({
  command,
  description,
  action,
  args,
  opts,
  subCommands,
  hidden = false
}: BuildCommandArgs<T>): Command {
  const cmd = _origCommand<T>(command, { description, hidden });

  if (opts) {
    const actualOpts: OptionMap = typeof opts === "function" ? opts({}) : opts;

    Object.entries(actualOpts).forEach(([optName, config]) => {
      cmd.option(optName, config);
    });
  }

  if (args) {
    const actualArgs: ArgMap = typeof args === "function" ? args({}) : args;

    Object.entries(actualArgs).forEach(([argName, config]) => {
      cmd.argument(argName, config);
    });
  }

  if (action) {
    cmd.action(action);
  }

  if (subCommands) {
    for (const subCommand of subCommands) {
      cmd.add(subCommand);
    }
  }

  return cmd;
}

[khill-fbmc]

And its use...

[hongaar]

This looks very good. One of the influences for this library is vorpal, which uses the fluent interface.

I'm hesitant to add your suggestion to the library, as I don't want to offer multiple ways of doing the same thing. This adds complexity and makes (imo) e.g. yargs harder to use than it could be.

I do have some doubts about the fluent interface myself, maybe I will look into changing the API for a next major release.

[khill-fbmc]

I get the appeal of the fluent interface and I do like it. I'm not saying it's bad.

I get that adding another means to an end would be taking on extra overhead.

I was just testing out an idea anyways, haha. I want to use your lib and plug in a directory that has all my commands. It would automatically add parent commands as the folder names and the contents' files as sub commands.

[khill-fbmc]

Love the library, it is making my life easy, so thank you 🙂