Better error handling for Union (not Discriminated Unions)

[Lonli-Lokli]

Given this code, there is no way for me to get proper error

const firstOption = Type.Object({
  key_column: Type.String(),
  panel: Type.Object({
    id: Type.String(),
  }),
});

const secondOption = Type.Object({
  panel: Type.Object({
    id: Type.Optional(Type.String()),
    title: Type.String(),
  }),
});
const multi = Type.Object({ schema: Type.Union([firstOption, secondOption]) });

const data = {
  schema: {
    panel: {
      id: 1,
      title: 1,
    },
  },
};

const error = TypeCompiler.Compile(multi).Errors(data).First();

What are you usually doing for this?

[sinclairzx81]

@Lonli-Lokli Hi,

You can obtain union variant errors by accessing the .errors property on ValueError. This property contains an array of iterators where each iterator maps to errors generated by each Union variant. The following just yields the first error for both firstOption and secondOption.

const error = TypeCompiler.Compile(multi).Errors(data).First()!;

console.log(error)                    // {
                                      //   type: 62,
                                      //   schema: { anyOf: [ [Object], [Object] ], [Symbol(TypeBox.Kind)]: 'Union' },
                                      //   path: '/schema',
                                      //   value: { panel: { id: 1, title: 1 } },
                                      //   message: 'Expected union value',
                                      //   errors: [
                                      //     ValueErrorIterator2 { iterator: Object [Generator] {} },  // firstOption
                                      //     ValueErrorIterator2 { iterator: Object [Generator] {} }   // secondOption
                                      //   ]
                                      // }

console.log(error.errors[0].First())  // {
                                      //   type: 45,
                                      //   schema: { type: 'string', [Symbol(TypeBox.Kind)]: 'String' },
                                      //   path: '/schema/key_column',
                                      //   value: undefined,
                                      //   message: 'Expected required property',
                                      //   errors: []
                                      // }

console.log(error.errors[1].First())  // {
                                      //   type: 54,
                                      //   schema: {
                                      //     type: 'string',
                                      //     [Symbol(TypeBox.Kind)]: 'String',
                                      //     [Symbol(TypeBox.Optional)]: 'Optional'
                                      //   },
                                      //   path: '/schema/panel/id',
                                      //   value: 1,
                                      //   message: 'Expected string',
                                      //   errors: []
                                      // }

To extract all errors, you will likely want to write a recursive function to pull the errors out.

// ...

type MappedError = [{ message: string, path: string, errors: MappedError[] }]


const MapErrorIterator = (iterator: ValueErrorIterator): MappedError[] => (
  [...iterator].map(error => MapError(error)) as never
)

const MapError = (error: ValueError) => ({
  message: error.message, 
  path: error.path,
  errors: error.errors.map(iterator => MapErrorIterator(iterator))
})


// ...

const R = MapErrorIterator(TypeCompiler.Compile(multi).Errors(data)) // [
                                                                     //   {
                                                                     //     message: 'Expected union value',
                                                                     //     path: '/schema',
                                                                     //     errors: [
                                                                     //       [
                                                                     //         {
                                                                     //           message: 'Expected required property',
                                                                     //           path: '/schema/key_column',
                                                                     //           errors: []
                                                                     //         },
                                                                     //         {
                                                                     //           message: 'Expected string',
                                                                     //           path: '/schema/key_column',
                                                                     //           errors: []
                                                                     //         },
                                                                     //         {
                                                                     //           message: 'Expected string',
                                                                     //           path: '/schema/panel/id',
                                                                     //           errors: []
                                                                     //         }
                                                                     //       ],
                                                                     //       [
                                                                     //         {
                                                                     //           message: 'Expected string',
                                                                     //           path: '/schema/panel/id',
                                                                     //           errors: []
                                                                     //         },
                                                                     //         {
                                                                     //           message: 'Expected string',
                                                                     //           path: '/schema/panel/title',
                                                                     //           errors: []
                                                                     //         }
                                                                     //       ]
                                                                     //     ]
                                                                     //   }
                                                                     // ]

TypeBox doesn't currently provide any utility methods to extract or map errors. So you will need to use the above to map the errors into forms accepted by your application.

Hope this helps
S

[Lonli-Lokli]

So the problem I have now with current unions is that I might have one of two responses (combined via Union), each of the responses can again contain different unions, and I cannot express them as Discriminated because they sometimes not related at all, eg I can determine that it's typeA because it has property cells, while all other do not have it (and it is different from DiscriminatedUnion)

While I still want to have better error handling with better errors, describing what's wrong.

[Lonli-Lokli]

So I would it say better errors are one case for anyOf which is missing in TypeBox for known reasons. I would say that with Unions it's not possible to get good errors describing problem (generic message is right here), while when we kknow that provided value must be one of those we can understand by chain of thoughts what is it, eg by discriminator key or in guard

[Lonli-Lokli]

I mean even with this implementation I am getting generic error instead of proper one