Migrating away from legacy, missing filter

[ghiscoding]

Hello, I'm trying to migrate to the new approach in the Lerna-Lite project that I maintain and I see that there's no filter anywhere which was available in the legacy question interface. So I'm not sure how I'm supposed to migrate

Below is the old code, so in Lerna-Lite (which the code came from Lerna), they created a prompt.ts (which can be found here: prompt.ts) as a wrapper to do simple things like promptConfirmation, promptSelectOne and promptTextInput (the latter is the one I'm trying to migrate)

export async function promptTextInput(message, { filter, validate } = {}): Promise<string> {
  const answers = await inquirer.prompt([
    {
      type: 'input',
      name: 'input',
      message,
      filter,
      validate,
    },
  ]);

  return answers.input;
}

what I have so far is like below but I'm not sure what to do with the missing filter

export async function promptTextInput(message: string, { filter, validate } = {}): Promise<string> {
  const answers = await input({
    message,
    filter,
    validate,
  });

  return answers;
}

and this is 2 examples of how it's being used in Lerna-Lite (same as Lerna)

return promptTextInput('Enter a custom version', {
  filter: semver.valid,
  // semver.valid() always returns null with invalid input
  validate: (v) => v !== null || 'Must be a valid semver version',
});

and this other example

const defaultVersion = semver.inc(currentVersion, 'prerelease', prereleaseId);
const prompt = `(default: "${prereleaseId}", yielding ${defaultVersion})`;

return promptTextInput(`Enter a prerelease identifier ${prompt}`, {
  filter: (v) => applyBuildMetadata(semver.inc(currentVersion, 'prerelease', v || prereleaseId), buildMetadata),
});

so I'd really like to migrate but... also why aren't the interfaces no longer exported? I would rather have the type available to properly add type to the arguments (it was available in v9 and lower but that seems to be gone in v10)
import { ListChoiceOptions, Question } from 'inquirer';

I guess I'll still upgrade to v10 but keep using the legacy approach until I get to know how to really migrate. Thanks for the great lib, the modern approach would be nice to migrate especially for the smaller footprint. Cheers

[SBoudrias]

Hi, thanks for the questions!

1 - Filters in new prompts (@inquirer/prompts, etc)

Those were removed from the API since filters only modified the return value. Because of this, it felt simpler to let you apply them as needed. Here's 2 suggestions:

const answers = filter(
  await input({
    message,
    validate,
  })
);

const answers = await input({
  message,
  validate,
}).then(filter);

2 - Type interfaces in v10

I never maintained types for v9 and earlier; those were made by the typescript community over at DefinitivelyTyped. I did looked into those types, but to get the right inference (where types will be less often required) I don't think I can commit to this interface (especially since v10 uses the new prompts instead of the complicated class based ones.)

That being said, I'm aware types in v10 are far from ideal and currently quite limited (or breaking for non-most-common use cases.) I'm actively working on types improvements for v10 and later (part of the ongoing work is here #1469 - but still lots to do.)

[ghiscoding]

hey thanks that's very helpful, however I had a failing unit test with your approach with your suggestion, I think that's because in your approach you forgot to break if the validate is invalid, it shouldn't go further. So I decided to go with the approach shown below, let me know if it make sense or if I misunderstood.

const promptResult = await input({ message, validate });

let finalResult = promptResult;
if (finalResult && typeof filter === 'function') {
  finalResult = filter(promptResult);
}
return finalResult;

now my old unit test is passing correctly after this change, the output should be falsy because the validate returned false, hence the output should also be false

it('should prompt text input and return false when validation is invalid', async () => {
  const isValid = false;
  (input as Mock).mockResolvedValueOnce(isValid);

  const logPauseSpy = vi.spyOn(log, 'pause');
  const logResumeSpy = vi.spyOn(log, 'resume');

  const output = await promptTextInput('Choose something...', {
    filter: () => true,
    validate: () => isValid,
  });
  expect(logPauseSpy).toHaveBeenCalled();
  expect(logResumeSpy).toHaveBeenCalled();
  expect(input).toHaveBeenCalled();
  expect(output).toBeFalsy();
});

as for the interface, I guess I'll have to go with inlining these 2 interfaces, I would rather use the official interfaces if available but inlining will do for my simple prompt wrappers.

interface ListChoiceOptions {
  value: string;
  name?: string;
  description?: string;
  disabled?: boolean | string;
}

interface Question {
  choices: ListChoiceOptions[];
  filter?: (args: any) => any;
  validate?: (value: string) => boolean | string | Promise<string | boolean>;
}

hey that would be really great if you could verify my Lerna-Lite PR to confirm that my migration is correct (or wrong)

... I just noticed that we're both from Montreal... bonjour a toi aussi :)

[SBoudrias]

Oh hey salut! 👋🏻

I'm not sure I totally follow the problem you're encountering with filter. input can return no value, but this can be modified with either required or validate. If you don't want to call filter with an empty value, then your approach is correct; that's what I'd do.

Reading your code, I don't think you should use ListChoiceOptions or Question. They very broad type and I think might end up complexifying your implementation or limiting Typescript proper inferrence.

You can extract the config of each prompts with Parameters<typeof input>[0]. And then add ['choices'] or other to extract specific types.

[SBoudrias]

Left you a few specific suggestions with the types on your PR. Hope this helps!