Implementing Design Patterns

type UserConnection {
  edges: [UserEdge!]!
  pageInfo: PageInfo!
  totalCount: Int
}
type UserEdge { cursor: String!, node: User! }
type PageInfo {
  hasNextPage: Boolean!
  hasPreviousPage: Boolean!
  startCursor: String
  endCursor: String
}

interface Node { id: ID! }
type User implements Node {
  id: ID!  # base64("User:123")
  email: EmailAddress!
}
type Query {
  node(id: ID!): Node
  nodes(ids: [ID!]!): [Node]!
}

type Query {
  viewer: Viewer!
}
type Viewer {
  user: User!
  notifications(first: Int): NotificationConnection!
  preferences: Preferences!
}

type CreateUserPayload {
  user: User
  userEdge: UserEdge  # for cache insertion
  clientMutationId: String
  errors: [UserError!]
}

union LoginResult = LoginSuccess | InvalidCredentials | MFARequired

type LoginSuccess { token: String!, user: User! }
type InvalidCredentials { message: String! }
type MFARequired { challengeId: ID! }

class UserRepository {
  constructor(private db, private cache) {}
  findById(id) { return this.cache.wrap(`u:${id}`, () => this.db.user.findUnique({ where: { id } })); }
  create(input) { return this.db.user.create({ data: input }); }
}

context: () => ({ users: new UserRepository(db, cache) })

const createLoaders = (db) => ({
  userById: new DataLoader((ids) => batchUsers(db, ids)),
  postsByUser: new DataLoader((ids) => batchPostsByUser(db, ids))
});

context: () => ({ db, loaders: createLoaders(db) })