Example of inputs or objects inheriting/sharing fields?

[mmahalwy]

Would it help to add an example of objects or inputs that share fields?

For example, create and update inputs share similar fields, with id being the differing one.

[hayes]

More docs are always good! This isn't something I've looked into yet. If you have a good pattern (or suggestion for an API addition that would make it easier) I'm definitely open to it!

[mmahalwy]

@hayes given this example:

const objectAFields = <T>(t: T) => ({
  foo: t.exposeString('foo', {}),
});

class ObjectA {
  foo: string;
}

const ObjectAObject = builder.objectType(ObjectA, {
  name: 'ObjectA',
  fields: objectAFields<SomeGiraphqlHelper>,
});

class ObjectB extends ObjectA {
  bar: string;
}

const ObjectBObject = builder.objectType(ObjectB, {
  name: 'ObjectA',
  fields: (t) => ({
    ...objectAFields(t),
    bar: t.exposeString('bar', {}),
  }),
});

Ideally, there is a helper to pass in the type for objectAFields function. Prisma provides something like this:

https://www.prisma.io/docs/concepts/components/prisma-client/advanced-type-safety/operating-against-partial-structures-of-model-types#solution

[hayes]

@mmahalwy added this for you https://giraphql.com/guide/patterns#sharing-fields-between-types

[mmahalwy]

@hayes this is awesome. Thanks for sharing. I really like the pattern for common args and common inputs. Going to use the inputs especially as I have many CreateXYZInput and UpdateXYZInput that share almost all the fields on the input. Curious, how come the pattern for common objects is different? Why not have a function that spreads the common fields across objects in the implement method? That would be similar to how common fields on input would be done.

Lastly, I'd imagine it's not possible to have common fields across input and object? I find myself having to repeat the fields for input and object often. This might be a bit more of an edge-case but here is an example:

export const UserObject = builder
  .objectRef<User>('User')
  .implement({
    fields: (t) => ({
      id: t.exposeID('id', {}),
      firstName: t.exposeString('content', { nullable: true }),
      email: t.exposeString('content'),
    }),
  });

const CreateUserInput = builder.inputType('CreateUserInput', {
  fields: (t) => ({
    firstName: t.string({}),
    email: t.string({ required: true }),
  }),
});

Just a thought there :)

[hayes]

This might be something you could create a plugin for. You could add a generateInputObject: { ....input opions } option on object types, and then have a similar option on each field you want to generate an input field for. Probably not something I will build my self, but wouldn't be too hard as a custom plugin 🤷 .

For the object fields pattern, you can definitely use the same pattern, it is just easier (fewer types) to explain without the pattern in the docs.

function createObjectFieldsFromBuilder(
  t: GiraphQLSchemaTypes.ObjectFieldBuilder<TypesWithDefault, { id: string }>,
) {
  return {
    id: t.exposeID('id', {}),
    idLength: t.int({
      resolve: (parent) => parent.id.length,
    }),
  };
}

[haleksandre]

Is there a way to still achieve this pattern with the newer Pothos versions? Can't seem to find the GiraphQLSchemaTypes Pothos' alternative types?

I'm also using Prisma plugin which looks like t gets typed with the generic PrismaObjectFieldBuilder but I can't seem to be able to populate its arguments correctly.

[hayes]

GiraphQLSchemaTypes is now PothosSchemaTypes

[hayes]

there is something similar in the docs: https://pothos-graphql.dev/docs/guide/patterns. Doing this with prisma get's more complicated. You can add normal object fields to prisma objects, but getting prisma specific options (select, relations, etc) would be more tricky

[mmahalwy]

imho, I'd lead with this as an example in the docs! I love this pattern :)