builder.args vs Reusable Args Pattern from Docs

[arimgibson]

Hey there! Working on DRY-ing some argument declarations for a large project using Prisma, Pothos, and Relay.

As far as I can tell; there is no difference in return types from these two methods... one uses builder.args and one uses this more complex pattern from the docs.

builder.args

export const conversationFilterArgs = builder.args((t) => ({
  conversation_medium: t.field({
    type: ConversationMedium, // this is an enum pulled from Prisma schema
  }),
  status: t.field({
    type: ConversationStatus,
  }),
}));

Args pattern from docs

export interface SchemaTypes {
  AuthScopes: {
    public: boolean;
  },
  Context: GraphQLContext,
  Scalars: {
    ...
  },
  PrismaTypes: PrismaTypes,
  Objects: {
     ...
  }
}

export type BuilderTypesWithDefaults = PothosSchemaTypes.ExtendDefaultTypes<SchemaTypes>;

export function commonArgs(arg: ArgBuilder<BuilderTypesWithDefaults>) {
  return {
    conversation_medium: arg({
      type: ConversationMedium,
    }),
    status: arg({
      type: ConversationStatus,
    }),
  };
}

Return types

type CommonArgsReturn = ReturnType<typeof commonArgs>;
{
    conversation_medium: InputFieldRef<ValuesFromEnum<{
// redacted
    }> | null | undefined, "Arg">;
    status: InputFieldRef<ValuesFromEnum<{
// redacted
    }> | null | undefined, "Arg">;
}

type ConversationFilterArgsReturn = typeof conversationFilterArgs;
{
    conversation_medium: InputFieldRef<ValuesFromEnum<{
// redacted
    }> | null | undefined, "Arg">;
    status: InputFieldRef<ValuesFromEnum<{
// redacted
    }> | null | undefined, "Arg">;
}

Is there any reason anyone would want to use the more complex pattern that the docs currently recommend? If not, are the docs out of date? Would be happy to PR an updated example and text. Thanks as always!

[hayes]

I think using builder.args is probably in general better. The one caveat I'd add is that the current version of Pothos was not intended to re-use args.

I'm not sure if you'll run into any issues if you re-use the same arg refs on multiple fields. It's probably safer to do something like:

export const createConversationFilterArgs = () => builder.args((t) => ({
  conversation_medium: t.field({
    type: ConversationMedium, // this is an enum pulled from Prisma schema
  }),
  status: t.field({
    type: ConversationStatus,
  }),
}));

Pothos v4 refactors a lot of things so that it will be safer to re-use refs, or combine refs created by separate builders