fix(core): escape the body type when wrapping props in BodyType<T> - #4123

I was looking at how the BodyType<T> envelope gets applied to the body parameter and noticed that four clients build the rewrite regex by interpolating body.definition straight into a RegExp:

toObjectString(props, 'implementation').replace(
  new RegExp(String.raw`(\w*):\s?${body.definition}`),
  `$1: ${mutator.bodyTypeName}<${body.definition}>`,
)

body.definition is a TypeScript type, so it regularly contains regex metacharacters. @orval/query already escapes this exact value in wrapPropsBodyWithMutatorBodyType; packages/axios, packages/swr, packages/solid-start, the Angular HttpClient generator and the request function in packages/query/src/client.ts (which only escaped the first []) do not.

What that produces, with a mutator that exports BodyType<T> (I used tests/mutators/custom-client.ts) and a spec with an array request body and a oneOf request body:

# client: 'axios', before
const createPets = (
    pet: Pet[],                                     <- envelope silently dropped
const createAnimal = (
    petCat: CreateAnimalBodyType<Pet | Cat>| Cat,   <- widened back to the bare type

Pet[] ends with [], an empty character class that can never match, so the whole pattern fails and the parameter keeps the raw type. Pet | Cat turns the pattern into an alternation, the | Cat branch survives into the output, and the parameter accepts a plain Cat again — which defeats the point of the envelope when BodyType<T> is not just T & {...}.

The Angular copy is a separate flavour of the same mistake. It was moved to String.raw without dropping the doubled escapes, so the pattern is (\\w*):\\s? and expects a literal backslash in the props string. It never wraps anything at all, and on a union body only the stray | Cat alternative matches, with $1 undefined:

# client: 'angular', before
 createPets<TData = void>(
    pet: Pet[],
 createAnimal<TData = void>(
    petCat: Pet |: CreateAnimalBodyType<Pet | Cat>,   <- generated file does not parse

Following review, the fix no longer builds a regex from the definition at all. Each of the five generators picks the prop whose type is GetterPropType.BODY before toObjectString and replaces its trailing : ${body.definition} with the envelope, so metacharacters, $1/$& in an inline enum body, a path param typed PetStatus next to a Pet body, and a path param of the same type as the body are all handled by construction. Pet[] and Pet | Cat now come out as pet: BodyType<Pet[]> and pet: BodyType<Pet | Cat> in the unit tests of every generator.

I added unit tests next to each generator (Pet[], Pet | Cat, (Pet | Cat)[], plus a plain Pet for Angular since that one never matched either). They fail on master — 3 in axios, 3 in angular, 2 in swr, 2 in solid-start — and pass with the change.

I did not add a snapshot fixture: none of the committed ones pairs a metacharacter body type with a BodyType<T> mutator, and I checked that regenerating tests/configs/{axios,angular,swr,solid-start}.config.ts leaves tests/__snapshots__ byte-identical, so this is not a change to any currently generated output. vp fmt --check, vp lint --type-aware --type-check packages, typecheck and the unit suites of the four packages (plus core, query and fetch) are green.

Found by a defect-hunting pipeline I build and run (Dev-next-gen), using Claude Code with Anthropic's Claude Opus 5.

Summary by CodeRabbit

• Bug Fixes

  • Fixed generated Angular, Axios, Solid Start, SWR, and Query clients so request bodies with object, array, union, and literal types are correctly wrapped in the configured body type.
  • Preserved other request parameters, including path parameters sharing the body’s type, when applying body type wrappers.
  • Improved handling of complex body definitions containing special characters, preventing incorrect request-generation substitutions.

• Tests

  • Added coverage for varied request body definitions and parameter combinations across supported client generators.