Merge remote-tracking branch 'origin/main' into deps

Author: mmkal

.github/workflows/autofix.yml

@@ -16,4 +16,5 @@ jobs:
       - run: corepack enable
       - run: pnpm install --no-frozen-lockfile
       - run: pnpm run lint --fix
-      - uses: autofix-ci/action@635ffb0c9798bd160680f18fd73371e355b85f27
+      - run: git diff
+      - uses: autofix-ci/action@551dded8c6cc8a1054039c8bc0b8b48c51dfc6ef

README.md

@@ -224,14 +224,24 @@ Booleans:
    - no option supplied to `{foo: false}`
    - `--foo` `{foo: true}`
 
+
 - `z.object({foo: z.boolean().default(true)})` will map:
    - no option supplied to `{foo: true}`
-   - `--no-foo` `{foo: false}`
+   - `--foo false` or `--foo=false` to `{foo: false}`
 
 - `z.object({foo: z.boolean().optional()})` will map:
   - no option supplied to `{}` (foo is undefined)
   - `--foo` to `{foo: true}`
-  - `--foo false` to `{foo: false}` (note: `--no-foo` doesn't work here, because its existence prevents `{}` from being the default value)
+  - `--foo false` to `{foo: false}`
+
+Negated options can be useful for default-true booleans:
+
+- `z.object({foo: z.boolean().default(true).meta({negatable: true})})` will map:
+  - no option supplied to `{foo: true}`
+  - `--no-foo` to `{foo: false}`
+  - `--foo false` to `{foo: false}`
+
+(Note: you can set booleans to negatable-by-default by setting `negateBooleans: true` on the procedure's `meta`)
 
 Numbers:
 
@@ -333,7 +343,7 @@ You can also explicitly opt into this behavior for any procedure by setting `jso
 ### API docs
 
 <!-- codegen:start {preset: markdownFromJsdoc, source: src/index.ts, export: createCli} -->
-#### [createCli](./src/index.ts#L167)
+#### [createCli](./src/index.ts#L168)
 
 Run a trpc router as a CLI.
 
@@ -489,7 +499,7 @@ When passing a command along with its options, the return value will be logged t
 
 Invalid inputs are helpfully displayed, along with help text for the associated command:
 
-<!-- codegen:start {preset: custom, require: tsx/cjs, source: ./readme-codegen.ts, export: command, command: './node_modules/.bin/tsx test/fixtures/calculator add 2 notanumber', reject: false} -->
+<!-- TODO:reenable codegen:start {preset: custom, require: tsx/cjs, source: ./readme-codegen.ts, export: command, command: './node_modules/.bin/tsx test/fixtures/calculator add 2 notanumber', reject: false} -->
 `node path/to/calculator add 2 notanumber` output:
 
 ```

readme-codegen.ts

@@ -1,18 +1,18 @@
 import {createHash} from 'crypto'
+import {execaCommandSync} from 'execa'
 import stripAnsi from 'strip-ansi'
 
 export const command: import('eslint-plugin-mmkal').CodegenPreset<{command: string; reject?: false}> = ({
   options,
   meta,
-  dependencies: {zx},
 }) => {
-  const $ = zx.$({nothrow: !options.reject, sync: true})
-  const result = $`sh -c ${options.command}`
+  const result = execaCommandSync(options.command, {all: true, reject: options.reject})
+  if (!stripAnsi(result.all)) throw new Error(`Command ${options.command} had no output`)
   const output = [
     `\`${options.command.replace(/.* test\/fixtures\//, 'node path/to/')}\` output:`,
     '',
     '```',
-    stripAnsi(result.stdout), // includes stderr
+    stripAnsi(result.all), // includes stderr
     '```',
   ].join('\n')
 

src/index.ts

@@ -12,6 +12,7 @@ import {
   getDescription,
   getSchemaTypes,
   getEnumChoices,
+  getAllowedSchemas,
 } from './json-schema'
 import {lineByLineConsoleLogger} from './logging'
 import {parseProcedureInputs} from './parse-procedure'
@@ -258,109 +259,53 @@ export function createCli<R extends AnyRouter>({router, ...params}: TrpcCliParam
           delete unusedOptionAliases[propertyKey]
         }
 
-        const defaultValue =
-          'default' in propertyValue
-            ? ({exists: true, value: propertyValue.default} as const)
-            : ({exists: false} as const)
+        const allowedSchemas = getAllowedSchemas(propertyValue)
+        const firstSchemaWithDefault = allowedSchemas.find(subSchema => 'default' in subSchema)
+        const defaultValue = firstSchemaWithDefault
+          ? ({exists: true, value: firstSchemaWithDefault.default} as const)
+          : ({exists: false} as const)
 
         const rootTypes = getSchemaTypes(propertyValue).sort()
 
-        const parseJson = (value: string, ErrorClass: new (message: string) => Error = InvalidArgumentError) => {
-          try {
-            return JSON.parse(value) as {}
-          } catch {
-            throw new ErrorClass(`Malformed JSON.`)
-          }
-        }
-        /** try to get a parser that can confidently parse a string into the correct type. Returns null if it can't confidently parse */
-        const getValueParser = (types: ReturnType<typeof getSchemaTypes>) => {
-          types = types.map(t => (t === 'integer' ? 'number' : t))
-          if (types.length === 2 && types[0] === 'boolean' && types[1] === 'number') {
-            return {
-              type: 'boolean|number',
-              parser: (value: string) => booleanParser(value, {fallback: null}) ?? numberParser(value),
-            } as const
-          }
-          if (types.length === 1 && types[0] === 'boolean') {
-            return {type: 'boolean', parser: (value: string) => booleanParser(value)} as const
-          }
-          if (types.length === 1 && types[0] === 'number') {
-            return {type: 'number', parser: (value: string) => numberParser(value)} as const
-          }
-          if (types.length === 1 && types[0] === 'string') {
-            return {type: 'string', parser: null} as const
-          }
-          return {
-            type: 'object',
-            parser: (value: string) => {
-              const parsed = parseJson(value)
-              if (!types.length) return parsed // if types is empty, it means any type is allowed - e.g. for json input
-              const jsonSchemaType = Array.isArray(parsed) ? 'array' : parsed === null ? 'null' : typeof parsed
-              if (!types.includes(jsonSchemaType)) {
-                throw new InvalidArgumentError(`Got ${jsonSchemaType} but expected ${types.join(' or ')}`)
-              }
-              return parsed
-            },
-          } as const
-        }
-
         const propertyType = rootTypes[0]
         const isValueRequired =
           'required' in parsedProcedure.optionsJsonSchema &&
           parsedProcedure.optionsJsonSchema.required?.includes(propertyKey)
         const isCliOptionRequired = isValueRequired && propertyType !== 'boolean' && !defaultValue.exists
 
         function negate() {
-          const negation = new Option(longOption.replace('--', '--no-'), `Negate \`${longOption}\` option.`.trim())
-          command.addOption(negation)
+          const shouldNegate = 'negatable' in propertyValue ? propertyValue.negatable : meta.negateBooleans
+          if (shouldNegate) {
+            const negation = new Option(longOption.replace('--', '--no-'), `Negate \`${longOption}\` option.`.trim())
+            command.addOption(negation)
+          }
         }
 
         const bracketise = (name: string) => (isCliOptionRequired ? `<${name}>` : `[${name}]`)
 
-        if (rootTypes.length === 2 && rootTypes[0] === 'boolean' && rootTypes[1] === 'string') {
-          const option = new Option(`${flags} [value]`, description)
-          option.default(defaultValue.exists ? defaultValue.value : false)
-          command.addOption(option)
-          negate()
-          return
-        }
-        if (rootTypes.length === 2 && rootTypes[0] === 'boolean' && rootTypes[1] === 'number') {
+        if (allowedSchemas.length > 1) {
           const option = new Option(`${flags} [value]`, description)
-          option.argParser(getValueParser(rootTypes).parser!)
-          option.default(defaultValue.exists ? defaultValue.value : false)
-          command.addOption(option)
-          negate()
-          return
-        }
-        if (rootTypes.length === 2 && rootTypes[0] === 'number' && rootTypes[1] === 'string') {
-          const option = new Option(`${flags} ${bracketise('value')}`, description)
-          option.argParser(value => {
-            const number = numberParser(value, {fallback: null})
-            return number ?? value
-          })
           if (defaultValue.exists) option.default(defaultValue.value)
+          else if (rootTypes.includes('boolean')) option.default(false)
+          option.argParser(getOptionValueParser(propertyValue))
           command.addOption(option)
+          if (rootTypes.includes('boolean')) negate()
           return
         }
 
         if (rootTypes.length !== 1) {
           const option = new Option(`${flags} ${bracketise('json')}`, description)
-          option.argParser(getValueParser(rootTypes).parser!)
+          option.argParser(getOptionValueParser(propertyValue))
           command.addOption(option)
           return
         }
 
-        if (propertyType === 'boolean' && isValueRequired) {
-          const option = new Option(flags, description)
-          option.default(defaultValue.exists ? defaultValue.value : false)
-          command.addOption(option)
-          negate()
-          return
-        } else if (propertyType === 'boolean') {
+        if (propertyType === 'boolean') {
           const option = new Option(`${flags} [boolean]`, description)
           option.argParser(value => booleanParser(value))
           // don't set a default value of `false`, because `undefined` is accepted by the procedure
-          if (defaultValue.exists) option.default(defaultValue.value)
+          if (isValueRequired) option.default(false)
+          else if (defaultValue.exists) option.default(defaultValue.value)
           command.addOption(option)
           negate()
           return
@@ -369,10 +314,7 @@ export function createCli<R extends AnyRouter>({router, ...params}: TrpcCliParam
         let option: Option | null = null
 
         // eslint-disable-next-line unicorn/prefer-switch
-        if (propertyType === 'string' && 'format' in propertyValue && (propertyValue.format as string) === 'json') {
-          // option = new Option(`${flags} ${bracketise('json')}`, description)
-          // option.argParser(value => parseJson(value, InvalidOptionArgumentError))
-        } else if (propertyType === 'string') {
+        if (propertyType === 'string') {
           option = new Option(`${flags} ${bracketise('string')}`, description)
         } else if (propertyType === 'boolean') {
           option = new Option(flags, description)
@@ -383,20 +325,18 @@ export function createCli<R extends AnyRouter>({router, ...params}: TrpcCliParam
           option = new Option(`${flags} [values...]`, description)
           if (defaultValue.exists) option.default(defaultValue.value)
           else if (isValueRequired) option.default([])
-          const itemsProp = 'items' in propertyValue ? (propertyValue.items as JsonSchema7Type) : null
-          const itemTypes = itemsProp ? getSchemaTypes(itemsProp) : []
+          const itemsSchema = 'items' in propertyValue ? (propertyValue.items as JsonSchema7Type) : {}
 
-          const itemEnumTypes = itemsProp && getEnumChoices(itemsProp)
+          const itemEnumTypes = getEnumChoices(itemsSchema)
           if (itemEnumTypes?.type === 'string_enum') {
             option.choices(itemEnumTypes.choices)
           }
 
-          const itemParser = getValueParser(itemTypes)
-          if (itemParser.parser) {
-            option.argParser((value, previous) => {
-              const parsed = itemParser.parser(value)
-              if (Array.isArray(previous)) return [...previous, parsed] as unknown[]
-              return [parsed] as unknown[]
+          const itemParser = getOptionValueParser(itemsSchema)
+          if (itemParser) {
+            option.argParser((value, previous): unknown[] => {
+              const parsed = itemParser(value)
+              return Array.isArray(previous) ? [...previous, parsed] : [parsed]
             })
           }
         }
@@ -441,7 +381,6 @@ export function createCli<R extends AnyRouter>({router, ...params}: TrpcCliParam
         program.__ran ||= []
         program.__ran.push(command)
         const options = command.opts()
-        // console.dir({options, args}, {depth: null})
 
         if (args.at(-2) !== options) {
           // This is a code bug and not recoverable. Will hopefully never happen but if commander totally changes their API this will break
@@ -672,3 +611,57 @@ const booleanParser = (val: string, {fallback = val as unknown} = {}) => {
   if (val === 'false') return false
   return fallback
 }
+
+const getOptionValueParser = (schema: JsonSchema7Type) => {
+  const allowedSchemas = getAllowedSchemas(schema)
+    .slice()
+    .sort((a, b) => String(getSchemaTypes(a)[0]).localeCompare(String(getSchemaTypes(b)[0])))
+
+  const typesArray = allowedSchemas.flatMap(getSchemaTypes)
+  const types = new Set(typesArray)
+
+  return (value: string) => {
+    const definitelyPrimitive = typesArray.every(
+      t => t === 'boolean' || t === 'number' || t === 'integer' || t === 'string',
+    )
+    if (types.size === 0 || !definitelyPrimitive) {
+      // parse this as JSON - too risky to fall back to a string because that will probably do the wrong thing if someone passes malformed JSON like `{"foo": 1,}` (trailing comma)
+      const hint = `Malformed JSON. If passing a string, pass it as a valid JSON string with quotes (${JSON.stringify(value)})`
+      const parsed = parseJson(value, InvalidOptionArgumentError, hint)
+      if (!types.size) return parsed // if types is empty, it means any type is allowed - e.g. for json input
+      const jsonSchemaType = Array.isArray(parsed) ? 'array' : parsed === null ? 'null' : typeof parsed
+      if (!types.has(jsonSchemaType)) {
+        throw new InvalidOptionArgumentError(`Got ${jsonSchemaType} but expected ${[...types].join(' or ')}`)
+      }
+      return parsed
+    }
+    if (types.has('boolean')) {
+      const parsed = booleanParser(value, {fallback: null})
+      if (typeof parsed === 'boolean') return parsed
+    }
+    if (types.has('number')) {
+      const parsed = numberParser(value, {fallback: null})
+      if (typeof parsed === 'number') return parsed
+    }
+    if (types.has('integer')) {
+      const parsed = numberParser(value, {fallback: null})
+      if (typeof parsed === 'number' && Number.isInteger(parsed)) return parsed
+    }
+    if (types.has('string')) {
+      return value
+    }
+    throw new InvalidOptionArgumentError(`Got ${JSON.stringify(value)} but expected ${[...types].join(' or ')}`)
+  }
+}
+
+const parseJson = (
+  value: string,
+  ErrorClass: new (message: string) => Error = InvalidArgumentError,
+  hint = `Malformed JSON.`,
+) => {
+  try {
+    return JSON.parse(value) as {}
+  } catch {
+    throw new ErrorClass(hint)
+  }
+}

src/json-schema.ts

@@ -100,7 +100,7 @@ export const getDescription = (v: JsonSchema7Type, depth = 0): string => {
 
 export const getSchemaTypes = (
   propertyValue: JsonSchema7Type,
-): Array<'string' | 'boolean' | 'number' | (string & {})> => {
+): Array<'string' | 'boolean' | 'number' | 'integer' | (string & {})> => {
   const array: string[] = []
   if ('type' in propertyValue) {
     array.push(...[propertyValue.type].flat())
@@ -123,6 +123,18 @@ export const getSchemaTypes = (
   return [...new Set(array)]
 }
 
+/** Returns a list of all allowed subschemas. If the schema is not a union, returns a list with a single item. */
+export const getAllowedSchemas = (schema: JsonSchema7Type): JsonSchema7Type[] => {
+  if (!schema) return []
+  if ('anyOf' in schema && Array.isArray(schema.anyOf))
+    return (schema.anyOf as JsonSchema7Type[]).flatMap(getAllowedSchemas)
+  if ('oneOf' in schema && Array.isArray(schema.oneOf))
+    return (schema.oneOf as JsonSchema7Type[]).flatMap(getAllowedSchemas)
+  const types = getSchemaTypes(schema)
+  if (types.length === 1) return [schema]
+  return types.map(type => ({...schema, type}))
+}
+
 export const getEnumChoices = (propertyValue: JsonSchema7Type) => {
   if (!propertyValue) return null
   if (!('enum' in propertyValue && Array.isArray(propertyValue.enum))) {

src/types.ts

@@ -53,6 +53,8 @@ export interface TrpcCliMeta {
   jsonInput?: boolean
   /** Sub-property for the CLI meta. If present, will take precedence over the top-level meta, to avoid conflicts with other tools. */
   cliMeta?: TrpcCliMeta
+  /** If set to true, add a "--no-*" option to negate each boolean option by default. Can still be overriden by doing `z.boolean().meta({negatable: ...})` or equivalent. */
+  negateBooleans?: boolean
 }
 
 export interface ParsedProcedure {

test/arktype.test.ts

@@ -517,12 +517,10 @@ test('defaults and negations', async () => {
 
   expect(await run(router, ['optional-boolean'])).toMatchInlineSnapshot(`"{}"`)
   expect(await run(router, ['optional-boolean', '--foo'])).toMatchInlineSnapshot(`"{ foo: true }"`)
-  expect(await run(router, ['optional-boolean', '--no-foo'])).toMatchInlineSnapshot(`"{ foo: false }"`)
   expect(await run(router, ['optional-boolean', '--foo', 'true'])).toMatchInlineSnapshot(`"{ foo: true }"`)
   expect(await run(router, ['optional-boolean', '--foo', 'false'])).toMatchInlineSnapshot(`"{ foo: false }"`)
 
   expect(await run(router, ['default-true-boolean'])).toMatchInlineSnapshot(`"{ foo: true }"`)
-  expect(await run(router, ['default-true-boolean', '--no-foo'])).toMatchInlineSnapshot(`"{ foo: false }"`)
 
   expect(await run(router, ['default-false-boolean'])).toMatchInlineSnapshot(`"{ foo: false }"`)
   expect(await run(router, ['default-false-boolean', '--foo'])).toMatchInlineSnapshot(`"{ foo: true }"`)

test/e2e.test.ts

@@ -418,7 +418,6 @@ test('fs copy help', async () => {
 
     Options:
       --force [boolean]  Overwrite destination if it exists (default: false)
-      --no-force         Negate \`--force\` option.
       -h, --help         display help for command
     "
   `)
@@ -480,9 +479,7 @@ test('fs copy', async () => {
 
     Options:
       --ignore-whitespace [boolean]  Ignore whitespace changes (default: false)
-      --no-ignore-whitespace         Negate \`--ignore-whitespace\` option.
       --trim [boolean]               Trim start/end whitespace (default: false)
-      --no-trim                      Negate \`--trim\` option.
       -h, --help                     display help for command
     "
   `)
@@ -498,9 +495,7 @@ test('fs diff', async () => {
 
     Options:
       --ignore-whitespace [boolean]  Ignore whitespace changes (default: false)
-      --no-ignore-whitespace         Negate \`--ignore-whitespace\` option.
       --trim [boolean]               Trim start/end whitespace (default: false)
-      --no-trim                      Negate \`--trim\` option.
       -h, --help                     display help for command
     "
   `)