What is the best practice when the database schema and the graphql schema do not correspond?

[ZCY-G]

For example, a graphql schema is associated with other schemas. After being generated by server-preset, both the operation resolvers and the object type resolvers will require the corresponding schema to be returned. However, I can clearly put it into the corresponding object type resolvers for processing. If I want to maintain type safety and hope that when the object type resolvers is implemented, parant resolvers can ignore the check of the corresponding fields. What is the best practice?

[eddeee888]

Hello,
Hopefully I understanding your question right: you are asking how to avoid having to resolve an object in the parent, because you want to resolve it at the field level using server preset.

In this case, the recommended way is to use mappers to let Codegen know your intention.

Let's use this :

# src/app/schema.graphql
type Query {
  user: User
}

type User {
  id: ID!
  name: String!
  favouriteBook: Book
}

type Book {
  id: ID!
  title: String!
}

And you may store a "User" this in your database:

{
  id: string;
  name: string;
  favouriteBookId?: string; // we store book records in a different table, and this ID is the foreign key
}

Then, you may use the Database User interface as your "mapper":

// src/app/schema.mappers.ts
export type UserMapper = {
  id: string;
  name: string;
  favouriteBookId?: string;
}

Now, you can return the database User in Query.user like this:

// src/app/Query/user.ts
export const user = () => {
  const dbUser = db.user.find("1");
  return dbUser;
}

And access dbUser as the first param in User field resolvers:

// src/app/User.ts
export const User = {
  favouriteBook: (dbUser) => {
    if(!dbUser.favouriteBookId) {
      return null;
    }
    
    const book = db.book.find(dbUser.favouriteBookId);

    return book;
  }
}

[ZCY-G]

It's not about a deeply nested ORM schema, but rather a deeply nested GraphQL schema; this is actually unrelated to the ORM.

My idea is as follows:

type Query {
  userById(id: ID!): User!
}

type User {
  id: ID!
  organization: Organization!
}

type Organization {
  id: ID!
  users: [User!]!
}

In this scenario, the types generated by codegen should look something like this:

interface User {
  __typename?: 'User';
  id: string | number;
-  organization: Organization;
+  organization?: Organization;
}

interface Organization {
  __typename?: 'Organization';
  id: string | number;
-  users: User[];
+  users?: User[];
}

type UserResolvers = {
  id?: string | number;
-  organization?: Organization;
+  organization: Organization;
}

type OrganizationResolvers = {
  id?: string | number;
-  users?: User[];
+  users: User[];
}

Essentially, for non-primitive GraphQL types or scalars, the responsibility shifts from operation resolvers down to object type resolvers.

[ZCY-G]

here is a deeper level:

type User {
  id: ID!
  roles: [Role!]!
}

type Role {
  id: ID!
  users: [User!]!
  systemPermissions: [SystemPermission!]!
}

type SystemPermission {
  id: ID!
  role: Role!
  interfacePermissions: [InterfacePermission!]!
}

type InterfacePermission {
  id: ID!
}

interface User {
  __typename?: 'User';
  id: string | number;
  roles?: Role[];
}

type UserResolvers = {
  id?: string | number;
  roles: Role[];
}

interface Role {
  id: string | number;
  systemPermissions?: SystemPermission[];
}

type RoleResolvers = {
  id?: string | number;
  systemPermissions: SystemPermission[];
}

interface SystemPermission {
  id: string | number;
  interfacePermissions?: InterfacePermission[];
}

type SystemPermissionResolvers = {
  id?: string | number;
  interfacePermissions: InterfacePermission[];
}

interface InterfacePermission {
  id: string | number;
}

[ZCY-G]

My understanding is that if there's a mismatch between the operation resolvers and the schema, GraphQL delegates the resolution of those fields to the object type resolvers. Is that right?

[eddeee888]

My understanding is that if there's a mismatch between the operation resolvers and the schema, GraphQL delegates the resolution of those fields to the object type resolvers. Is that right?

If you are talking about the default GraphQL behaviour, then no.
GraphQL just runs the provided field resolver all the time. The default field resolver in the GraphQL engine looks like this for a field called id:

// default behaviour
id: ({ id }) => id

Server Preset does the comparison you mentioned when you provide the mapper 🙂

[ZCY-G]

I'm talking about the type of typescript generated.