feat(args): Support checking options after parse function

fixes #162

.circleci/config.yml

@@ -7,6 +7,7 @@ jobs:
     working_directory: ~/cli
     environment:
       NYC: "yarn exec nyc -- --nycrc-path node_modules/@oclif/nyc-config/.nycrc"
+      FORCE_COLOR: "0"
     steps:
       - checkout
       - restore_cache: &restore_cache

src/args.ts

@@ -9,6 +9,7 @@ export interface IArg<T = string> {
   parse?: ParseFn<T>;
   default?: T | (() => T);
   options?: string[];
+  postParseOptions?: string[];
 }
 
 export interface ArgBase<T> {
@@ -19,6 +20,7 @@ export interface ArgBase<T> {
   default?: T | (() => T);
   input?: string;
   options?: string[];
+  postParseOptions?: string[];
 }
 
 export type RequiredArg<T> = ArgBase<T> & {

src/errors.ts

@@ -98,3 +98,10 @@ export class ArgInvalidOptionError extends CLIParseError {
     super({parse: {}, message})
   }
 }
+
+export class ArgInvalidPostParseOptionError extends CLIParseError {
+  constructor(arg: Arg<any>, input: string) {
+    const message = `Expected ${input} to be one of: ${arg.postParseOptions!.join(', ')} after parsing`
+    super({parse: {}, message})
+  }
+}

src/parse.ts

@@ -229,7 +229,11 @@ export class Parser<T extends ParserInput, TFlags extends OutputFlags<T['flags']
           if (arg.options && !arg.options.includes(token.input)) {
             throw new m.errors.ArgInvalidOptionError(arg, token.input)
           }
-          args[i] = arg.parse(token.input)
+          const parsedToken = arg.parse(token.input)
+          if (arg.postParseOptions && !arg.postParseOptions.includes(parsedToken)) {
+            throw new m.errors.ArgInvalidPostParseOptionError(arg, parsedToken)
+          }
+          args[i] = parsedToken
         } else {
           args[i] = token.input
         }

test/parse.test.ts

@@ -617,6 +617,23 @@ See more help with --help`)
     })
   })
 
+  describe('arg postParseOptions', () => {
+    it('accepts valid postParseOptions', () => {
+      const out = parse(['myotheropt'], {
+        args: [{name: 'foo', parse: s => s.toUpperCase(), postParseOptions: ['MYOPT', 'MYOTHEROPT']}],
+      })
+      expect(out.args.foo).to.equal('MYOTHEROPT')
+    })
+
+    it('fails when invalid', () => {
+      expect(() => {
+        parse(['invalidopt'], {
+          args: [{name: 'foo', parse: s => s.toUpperCase(), postParseOptions: ['MYOPT', 'MYOTHEROPT']}],
+        })
+      }).to.throw('Expected INVALIDOPT to be one of: MYOPT, MYOTHEROPT after parsing')
+    })
+  })
+
   describe('env', () => {
     it('accepts as environment variable', () => {
       process.env.TEST_FOO = '101'