Support joining input schemas

[laurent512]

Hi,

Thanks for the good work :)
Related to the V7, is there a way to chain schema so that they can be deconstructed in the action like the following ?

export const testAction = authActionClient
  .schema(z.object({ key: z.string() }))
  .schema(z.object({ id: z.string() }))
  .action(async ({ parsedInput: { key, id }, ctx: { userId } }) => {
    return {
      updated: true,
    };
  });

The reason I ask that is to have part of the schema defined at the client level :)

[laurent512]

For extra information, I tried, but it only allows you to deconstruct the last schema content, so here I would only have access to "id"

[TheEdoRan]

Yes, this is expected. What if you pass a non-object schema to the first or second schema method? Should the library overwrite it or throw a runtime error?
In addition, next-safe-action supports multiple validation libraries via TypeSchema, so it's all abstracted under the hood, and we can't just directly use methods from Zod (or any other lib) to extend object schemas in the library code.
A possible solution would be to pass the previous schema as a parameter to the schema callback function where you can then extend it using the proper method from the validation library of your choice (for instance, using extend with Zod).

[laurent512]

Thank you for your reply.

Would it be possible to have an optional argument in the schema method that would define what is done with the following schema provided if any?

function multipleschemahandler(current,next){
return ...
}

 export const testAction = authActionClient
        .schema(z.object({ key: z.string() }) , multipleschemahandler)
        .schema(z.object({ id: z.string() }))
        .action(async ({ parsedInput: { key, id }, ctx: { userId } }) => {
                      return {
                updated: true,
            };
        });

[TheEdoRan]

Don't think that would work. Instead, as explained above, the previous schema could be passed to the schema function, if you need to access it, like this:

export const testAction = authActionClient
  .schema(z.object({ key: z.string() }))
  .schema(async (prevSchema) => prevSchema.extend({ id: z.string() }))
  .action(async ({ parsedInput: { key, id }, ctx: { userId } }) => {
    return {
      updated: true,
    };
  });

I think this is doable and clean.

[laurent512]

Ok I think it should work for my case, thank you :)
Currently it gives a typescript error, is it expected?

[TheEdoRan]

Yes, it's not implemented yet. I'll work on this feature soon.

[TheEdoRan]

Added support for this feature in v7.1.0, recipe here.

[laurent512]

thank you <3

[laurent512]

By the way, I think it would be nice to have a way to define the schema joining method at the root of the safe actions instead.
That would simplify the generation of many actions based on the same action client.
( client = 1 schema joining method and 1 schema ; action = 1 schema)
It means that it does not rely on the creator of the schema to ensure the correct inheritance.

You said that this is impossible?