/
validate.ts
104 lines (93 loc) · 3.37 KB
/
validate.ts
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
import {CLIError} from '../errors'
import {
InvalidArgsSpecError,
RequiredArgsError,
RequiredFlagError,
UnexpectedArgsError,
} from './errors'
import {ParserArg, ParserInput, ParserOutput, Flag} from '../interfaces'
export function validate(parse: {
input: ParserInput;
output: ParserOutput;
}) {
function validateArgs() {
const maxArgs = parse.input.args.length
if (parse.input.strict && parse.output.argv.length > maxArgs) {
const extras = parse.output.argv.slice(maxArgs)
throw new UnexpectedArgsError({parse, args: extras})
}
const missingRequiredArgs: ParserArg<any>[] = []
let hasOptional = false
for (const [index, arg] of parse.input.args.entries()) {
if (!arg.required) {
hasOptional = true
} else if (hasOptional) {
// (required arg) check whether an optional has occurred before
// optionals should follow required, not before
throw new InvalidArgsSpecError({parse, args: parse.input.args})
}
if (arg.required && !parse.output.argv[index] && parse.output.argv[index] as any as number !== 0) {
missingRequiredArgs.push(arg)
}
}
if (missingRequiredArgs.length > 0) {
throw new RequiredArgsError({parse, args: missingRequiredArgs})
}
}
function validateAcrossFlags(flag: Flag<any>) {
const intersection = Object.entries(parse.input.flags)
.map(entry => entry[0]) // array of flag names
.filter(flagName => parse.output.flags[flagName] !== undefined) // with values
.filter(flagName => flag.exactlyOne && flag.exactlyOne.includes(flagName)) // and in the exactlyOne list
if (intersection.length === 0) {
// the command's exactlyOne may or may not include itself, so we'll use Set to add + de-dupe
throw new CLIError(`Exactly one of the following must be provided: ${[
...new Set(flag.exactlyOne?.map(flag => `--${flag}`)),
].join(', ')}`)
}
}
function validateFlags() {
for (const [name, flag] of Object.entries(parse.input.flags)) {
if (parse.output.flags[name] !== undefined) {
for (const also of flag.dependsOn || []) {
if (!parse.output.flags[also]) {
throw new CLIError(
`--${also}= must also be provided when using --${name}=`,
)
}
}
for (const also of flag.exclusive || []) {
// do not enforce exclusivity for flags that were defaulted
if (
parse.output.metadata.flags[also] &&
parse.output.metadata.flags[also].setFromDefault
)
continue
if (
parse.output.metadata.flags[name] &&
parse.output.metadata.flags[name].setFromDefault
)
continue
if (parse.output.flags[also]) {
throw new CLIError(
`--${also}= cannot also be provided when using --${name}=`,
)
}
}
for (const also of flag.exactlyOne || []) {
if (also !== name && parse.output.flags[also]) {
throw new CLIError(
`--${also}= cannot also be provided when using --${name}=`,
)
}
}
} else if (flag.required) {
throw new RequiredFlagError({parse, flag})
} else if (flag.exactlyOne && flag.exactlyOne.length > 0) {
validateAcrossFlags(flag)
}
}
}
validateArgs()
validateFlags()
}