Can the ErrorsPlugin be applied to validation of scalars used as input args?

[mdavieselsevier]

If I use the ValidationPlugin and the ErrorsPlugin together I am able to handle bad inputs and give a clear response indicating where the problem is.

However, if I use scalars for my arguments this no longer seems to hold true.

Here's an example. For brevity I have not reproduced, here, the code to flatten Zod errors and create the ZodError type, but I have used the code from the docs: https://pothos-graphql.dev/docs/plugins/errors#with-validation-plugin

const max5Schema = z.number().int().max(5);

builder.queryType({
    fields: (t) => ({
        list: t.boolean({
            errors: { types: [ZodError] },
            nullable: true,
            args: {
                max5: t.arg.int({
                    validate: {
                        schema: max5Schema,
                    },
                }),
            },
            resolve: () => true,
        }),
    }),
});

If I then query, passing in 6 as the max5 parameter, the response is:

{
  "data": {
    "list": {
      "fieldErrors": [
        {
          "message": "Number must be less than or equal to 5",
          "path": [
            "max5"
          ]
        }
      ]
    }
  }
}

This is great, and exactly what I want from the response 🎉

However, if I wanted to present the max5 argument as a scalar, like this:

builder.scalarType('Max5', {
    serialize: (n) => n,
    parseValue: max5Schema.parse,
});

builder.queryType({
    fields: (t) => ({
        list: t.boolean({
            errors: { types: [ZodError] },
            nullable: true,
            args: {
                max5: t.arg({
                    type: 'Max5',
                }),
            },
            resolve: () => true,
        }),
    }),
});

The validation is still performed, and the Zod error is still thrown if the supplied value is not valid, but I no longer have the Zod error handled and my response is the errors array containing the stack trace 😞 :

{
  "errors": [
    {
      "message": "Variable \"$max5\" got invalid value 6; Expected type \"Max5\". [\n  {\n    \"code\": \"too_big\",\n    \"maximum\": 5,\n    \"type\": \"number\",\n    \"inclusive\": true,\n    \"message\": \"Number must be less than or equal to 5\",\n    \"path\": []\n  }\n]",
      "extensions": {
        "code": "BAD_USER_INPUT",
        "exception": {
          "stacktrace": [
            "ZodError: [",
            "  {",
            "    \"code\": \"too_big\",",
            "    \"maximum\": 5,",
            "    \"type\": \"number\",",
            "    \"inclusive\": true,",
            "    \"message\": \"Number must be less than or equal to 5\",",
            "    \"path\": []",
            "  }",
            "]",
            "    at handleResult ... full stack trace blah, blah, blah..."
          ]
        }
      }
    }
  ]
}

Is there any way around this? There doesn't seem to be anywhere else that I'm able to place the errors: { types: [ZodError] }, and I have also tried including ZodError in the errorOptions.defaultTypes list in the builder constructor.

Thank you.

[hayes]

Unfortunately I don't know of a good way to do this. Scalar validation is handle by graphql, and this happens at a completely different phase of execution, which means we can't catch the errors in the resolver. Pothos doesn't have a way to hook in or intercept this. One possible option might be to allow a custom validation option on scalar definitions that the does run during the resolver like other validation functions, and have the default parseValue function be more permissive.

[mdavieselsevier]

Ah, OK - thanks again for the quick response.

The custom validation option would sound useful. In all the cases I can think of that validation would be the same as what's now being done in parseValue. Is that a change to plugin-validator and/or pothos core then?

[mdavieselsevier]

Or were you suggesting it's something I can more or less achieve myself, albeit rather messily and losing the re-usable type safety of the scalar, like this?

builder.scalarType('Max5', {
    serialize: (n) => n,
    parseValue: (n) => n as number, // max5Schema.parse,
});

builder.queryType({
    fields: (t) => ({
        list: t.boolean({
            errors: { types: [ZodError] },
            nullable: true,
            args: {
                max5: t.arg({
                    type: 'Max5',
                    validate: {
                        schema: max5Schema,
                    },
                }),
            },
            resolve: () => true,
        }),
    }),
});

[hayes]

the above would work, I was imagining potentially adding something like: validate: { schema: max5Schema } directly to the scalar type, but this would be a new feature in the validation plugin that does not exist yet