find dataloader and very basic example

Author: darkbasic

examples/graphql/package.json

@@ -0,0 +1,30 @@
+{
+  "name": "graphql-example",
+  "private": true,
+  "version": "1.0.0",
+  "main": "lib/index.js",
+  "license": "MIT",
+  "mikro-orm": {
+    "useTsNode": true,
+    "configPaths": [
+      "./src/mikro-orm-config.ts",
+      "./lib/mikro-orm-config.js"
+    ]
+  },
+  "scripts": {
+    "start": "NODE_ENV=development yarn run -T nodemon -w src -x ts-node src/index.ts",
+    "test": "yarn run build"
+  },
+  "dependencies": {
+    "@mikro-orm/cli": "6.0.0-dev.187",
+    "@mikro-orm/core": "6.0.0-dev.187",
+    "@mikro-orm/entity-generator": "6.0.0-dev.187",
+    "@mikro-orm/knex": "6.0.0-dev.187",
+    "@mikro-orm/migrations": "6.0.0-dev.187",
+    "@mikro-orm/reflection": "6.0.0-dev.187",
+    "@mikro-orm/sqlite": "6.0.0-dev.187",
+    "graphql": "16.8.1",
+    "graphql-yoga": "5.0.0",
+    "tslib": "2.6.2"
+  }
+}

examples/graphql/src/entities/Author.ts

@@ -0,0 +1,40 @@
+import { Collection, Entity, ManyToMany, OneToMany, PrimaryKey, Property } from "@mikro-orm/core";
+import { Book } from "./Book";
+import { Chat } from "./Chat";
+
+@Entity()
+export class Author {
+  @PrimaryKey()
+  id!: number;
+
+  @Property()
+  name: string;
+
+  @Property()
+  email: string;
+
+  @OneToMany(() => Book, (book) => book.author)
+  books = new Collection<Book>(this);
+
+  // No inverse side exists
+  @ManyToMany(() => Author)
+  friends = new Collection<Author>(this);
+
+  // Inverse side exists
+  @ManyToMany(() => Author)
+  buddies = new Collection<Author>(this);
+
+  @ManyToMany(() => Author, (author) => author.buddies)
+  buddiesInverse = new Collection<Author>(this);
+
+  @OneToMany(() => Chat, (chat) => chat.owner)
+  ownedChats: Collection<Chat> = new Collection<Chat>(this);
+
+  constructor({ id, name, email }: { id?: number; name: string; email: string }) {
+    if (id != null) {
+      this.id = id;
+    }
+    this.name = name;
+    this.email = email;
+  }
+}

examples/graphql/src/entities/Book.ts

@@ -0,0 +1,26 @@
+import { Entity, ManyToOne, PrimaryKey, Property, Ref, ref } from "@mikro-orm/core";
+import { Author } from "./Author";
+import { Publisher } from "./Publisher";
+
+@Entity()
+export class Book {
+  @PrimaryKey()
+  id!: number;
+
+  @Property()
+  title: string;
+
+  @ManyToOne(() => Author, { ref: true })
+  author: Ref<Author>;
+
+  @ManyToOne(() => Publisher, { ref: true, nullable: true })
+  publisher!: Ref<Publisher> | null;
+
+  constructor({ id, title, author }: { id?: number; title: string; author: Author | Ref<Author> }) {
+    if (id != null) {
+      this.id = id;
+    }
+    this.title = title;
+    this.author = ref(author);
+  }
+}

examples/graphql/src/entities/Chat.ts

@@ -0,0 +1,22 @@
+import { Collection, Entity, ManyToOne, OneToMany, PrimaryKeyProp, Ref, ref } from "@mikro-orm/core";
+import { Author } from "./Author";
+import { Message } from "./Message";
+
+@Entity()
+export class Chat {
+  @ManyToOne(() => Author, { ref: true, primary: true })
+  owner: Ref<Author>;
+
+  @ManyToOne(() => Author, { ref: true, primary: true })
+  recipient: Ref<Author>;
+
+  [PrimaryKeyProp]?: ["owner", "recipient"];
+
+  @OneToMany(() => Message, (message) => message.chat)
+  messages: Collection<Message> = new Collection<Message>(this);
+
+  constructor({ owner, recipient }: { owner: Author | Ref<Author>; recipient: Author | Ref<Author> }) {
+    this.owner = ref(owner);
+    this.recipient = ref(recipient);
+  }
+}

examples/graphql/src/entities/Message.ts

@@ -0,0 +1,24 @@
+import { Entity, ManyToOne, PrimaryKey, Property, Ref, ref } from "@mikro-orm/core";
+import { Chat } from "./Chat";
+
+@Entity()
+export class Message {
+  @PrimaryKey()
+  id!: number;
+
+  @ManyToOne(() => Chat, { ref: true })
+  chat!: Ref<Chat>;
+
+  @Property()
+  content: string;
+
+  constructor({ id, chat, content }: { id?: number; chat?: Chat | Ref<Chat>; content: string }) {
+    if (id != null) {
+      this.id = id;
+    }
+    if (chat != null) {
+      this.chat = ref(chat);
+    }
+    this.content = content;
+  }
+}

examples/graphql/src/entities/Publisher.ts

@@ -0,0 +1,30 @@
+import { Collection, Entity, Enum, OneToMany, PrimaryKey, Property } from "@mikro-orm/core";
+import { Book } from "./Book";
+
+export enum PublisherType {
+  LOCAL = "local",
+  GLOBAL = "global",
+}
+
+@Entity()
+export class Publisher {
+  @PrimaryKey()
+  id!: number;
+
+  @Property()
+  name: string;
+
+  @OneToMany(() => Book, (book) => book.publisher)
+  books = new Collection<Book, Publisher>(this);
+
+  @Enum(() => PublisherType)
+  type = PublisherType.LOCAL;
+
+  constructor({ id, name = "asd", type = PublisherType.LOCAL }: { id?: number; name?: string; type?: PublisherType }) {
+    if (id != null) {
+      this.id = id;
+    }
+    this.name = name;
+    this.type = type;
+  }
+}

examples/graphql/src/index.ts

@@ -0,0 +1,81 @@
+/* eslint-disable @typescript-eslint/no-misused-promises */
+import { createSchema, createYoga } from "graphql-yoga";
+import { MikroORM } from "@mikro-orm/sqlite";
+import config from "./mikro-orm-config";
+import { populateDatabase } from "./utils/populateDatabase";
+import { assertSingleValue, executeOperation } from "./utils/yoga";
+import gql from "graphql-tag";
+import { Book } from "./entities/Book";
+import { Author } from "./entities/Author";
+import { EntityDataLoader } from "mikro-orm-find-dataloader";
+import { type EntityManager } from "@mikro-orm/core";
+
+const getAuthorsQuery = gql`
+  {
+    authors {
+      id
+      name
+      books {
+        id
+        title
+      }
+    }
+  }
+`;
+
+void (async () => {
+  const orm = await MikroORM.init(config);
+  let em: EntityManager;
+  em = orm.em.fork();
+  try {
+    await orm.schema.clearDatabase();
+  } catch (e) {
+    console.log("Couldn't clear databse");
+  }
+  try {
+    const generator = orm.getSchemaGenerator();
+    await generator.createSchema({ wrap: true });
+  } catch {
+    console.log("Schema has already been created");
+  }
+  await populateDatabase(em);
+  em = orm.em.fork();
+
+  const entityDataLoader = new EntityDataLoader(em);
+
+  const schema = createSchema({
+    typeDefs: gql`
+      type Query {
+        authors: [Author!]!
+      }
+      type Author {
+        id: ID!
+        name: String!
+        books: [Book!]!
+      }
+      type Book {
+        id: ID!
+        title: String!
+        author: Author!
+      }
+    `,
+    resolvers: {
+      Query: {
+        authors: async () => await em.find(Author, {}),
+      },
+      Author: {
+        books: async (author: Author) => {
+          // return await author.books.load();
+          // return await author.books.load({ dataloader: true });
+          // return await em.find(Book, { author: author.id });
+          return entityDataLoader.find(Book, { author: author.id });
+        },
+      },
+    },
+  });
+
+  const yoga = createYoga({ schema });
+  const res = await executeOperation(yoga, getAuthorsQuery);
+  assertSingleValue(res);
+  console.log(res.data.authors);
+})();

examples/graphql/src/mikro-orm-config.ts

@@ -0,0 +1,11 @@
+import { Author } from "./entities/Author";
+import { Book } from "./entities/Book";
+import { Chat } from "./entities/Chat";
+import { Message } from "./entities/Message";
+import { Publisher } from "./entities/Publisher";
+
+export default {
+  entities: [Author, Book, Chat, Message, Publisher],
+  dbName: ":memory:",
+  debug: true,
+};

examples/graphql/src/utils/populateDatabase.ts

@@ -0,0 +1,63 @@
+/* eslint-disable @typescript-eslint/no-non-null-assertion */
+import { ref, type MikroORM } from "@mikro-orm/core";
+import { Author } from "../entities/Author";
+import { Chat } from "../entities/Chat";
+import { Message } from "../entities/Message";
+import { Publisher } from "../entities/Publisher";
+import { Book } from "../entities/Book";
+
+export async function populateDatabase(em: MikroORM["em"]): Promise<void> {
+  const authors = [
+    new Author({ id: 1, name: "a", email: "[email protected]" }),
+    new Author({ id: 2, name: "b", email: "[email protected]" }),
+    new Author({ id: 3, name: "c", email: "[email protected]" }),
+    new Author({ id: 4, name: "d", email: "[email protected]" }),
+    new Author({ id: 5, name: "e", email: "[email protected]" }),
+  ];
+  authors[0]!.friends.add([authors[1]!, authors[3]!, authors[4]!]);
+  authors[0]!.friends.add([authors[1]!, authors[3]!, authors[4]!]);
+  authors[1]!.friends.add([authors[0]!]);
+  authors[2]!.friends.add([authors[3]!]);
+  authors[3]!.friends.add([authors[0]!, authors[2]!]);
+  authors[4]!.friends.add([authors[0]!]);
+  authors[0]!.buddies.add([authors[1]!, authors[3]!, authors[4]!]);
+  authors[0]!.buddies.add([authors[1]!, authors[3]!, authors[4]!]);
+  authors[1]!.buddies.add([authors[0]!]);
+  authors[2]!.buddies.add([authors[3]!]);
+  authors[3]!.buddies.add([authors[0]!, authors[2]!]);
+  authors[4]!.buddies.add([authors[0]!]);
+  em.persist(authors);
+
+  const chats = [
+    new Chat({ owner: authors[0]!, recipient: authors[1]! }),
+    new Chat({ owner: authors[0]!, recipient: authors[2]! }),
+    new Chat({ owner: authors[0]!, recipient: authors[4]! }),
+    new Chat({ owner: authors[2]!, recipient: authors[0]! }),
+  ];
+  chats[0]!.messages.add([new Message({ content: "A1" }), new Message({ content: "A2" })]);
+  chats[1]!.messages.add([new Message({ content: "B1" }), new Message({ content: "B2" })]);
+  chats[3]!.messages.add([new Message({ content: "C1" })]);
+  em.persist(chats);
+
+  const publishers = [new Publisher({ id: 1, name: "AAA" }), new Publisher({ id: 2, name: "BBB" })];
+  em.persist(publishers);
+
+  const books = [
+    new Book({ id: 1, title: "One", author: authors[0]! }),
+    new Book({ id: 2, title: "Two", author: authors[0]! }),
+    new Book({ id: 3, title: "Three", author: authors[1]! }),
+    new Book({ id: 4, title: "Four", author: authors[2]! }),
+    new Book({ id: 5, title: "Five", author: authors[2]! }),
+    new Book({ id: 6, title: "Six", author: authors[2]! }),
+  ];
+  books[0]!.publisher = ref(publishers[0]!);
+  books[1]!.publisher = ref(publishers[1]!);
+  books[2]!.publisher = ref(publishers[1]!);
+  books[3]!.publisher = ref(publishers[1]!);
+  books[4]!.publisher = ref(publishers[1]!);
+  books[5]!.publisher = ref(publishers[1]!);
+  em.persist(books);
+
+  await em.flush();
+  em.clear();
+}

examples/graphql/src/utils/yoga.ts

@@ -0,0 +1,27 @@
+import { buildHTTPExecutor } from "@graphql-tools/executor-http";
+import { type YogaServerInstance } from "graphql-yoga";
+import { type DocumentNode, type ExecutionResult } from "graphql";
+
+export function assertSingleValue<TValue extends object>(
+  value: TValue | AsyncIterable<TValue>,
+): asserts value is TValue {
+  if (Symbol.asyncIterator in value) {
+    throw new Error("Expected single value");
+  }
+}
+
+type MaybeAsyncIterable<T> = AsyncIterable<T> | T;
+
+export async function executeOperation(
+  yoga: YogaServerInstance<any, any>,
+  document: DocumentNode,
+): Promise<MaybeAsyncIterable<ExecutionResult<any, any>>> {
+  const executor = buildHTTPExecutor({
+    // eslint-disable-next-line @typescript-eslint/unbound-method
+    fetch: yoga.fetch,
+  });
+
+  return await executor({
+    document,
+  });
+}