Easier context binding alternative

Author: emmatown

packages/schema/README.md

@@ -6,16 +6,45 @@ constructing GraphQL Schemas while avoiding type-generation, [declaration mergin
 and [decorators](https://www.typescriptlang.org/docs/handbook/decorators.html).
 
 ```ts
-import { g } from "@graphql-ts/schema";
+import { initG } from "@graphql-ts/schema";
 import { GraphQLSchema, graphql } from "graphql";
 
+type Context = {
+  loadPerson: (id: string) => Person;
+  loadFriends: (id: string) => Person[];
+};
+const g = initG<Context>();
+type g<T> = initG<T>;
+
+type Person = {
+  id: string;
+  name: string;
+};
+
+const Person: g<typeof g.object<Person>> = g.object<Person>()({
+  name: "Person",
+  fields: () => ({
+    id: g.field({ type: g.ID }),
+    name: g.field({ type: g.String }),
+    friends: g.field({
+      type: g.list(Person),
+      resolve(source, _, context) {
+        return context.loadFriends(source.id);
+      },
+    }),
+  }),
+});
+
 const Query = g.object()({
   name: "Query",
   fields: {
-    hello: g.field({
-      type: g.String,
-      resolve() {
-        return "Hello!";
+    person: g.field({
+      type: Person,
+      args: {
+        id: g.arg({ type: g.ID }),
+      },
+      resolve(_, args, context) {
+        return context.loadPerson(args.id);
       },
     }),
   },
@@ -25,13 +54,37 @@ const schema = new GraphQLSchema({
   query: Query,
 });
 
+const people = new Map<string, Person>([
+  ["1", { id: "1", name: "Alice" }],
+  ["2", { id: "2", name: "Bob" }],
+]);
+const friends = new Map<string, string[]>([
+  ["1", ["2"]],
+  ["2", ["1"]],
+]);
+
 graphql({
   source: `
-    query {
-      hello
-    }
-  `,
+      query {
+        person(id: "1") {
+          id
+          name
+          friends {
+            id
+            name
+          }
+        }
+      }
+    `,
   schema,
+  context: {
+    loadPerson: (id) => people.get(id),
+    loadFriends: (id) => {
+      return (friends.get(id) ?? [])
+        .map((id) => people.get(id))
+        .filter((person) => person !== undefined);
+    },
+  },
 }).then((result) => {
   console.log(result);
 });

packages/schema/src/index.ts

@@ -7,16 +7,45 @@
  * [decorators](https://www.typescriptlang.org/docs/handbook/decorators.html).
  *
  * ```ts
- * import { g } from "@graphql-ts/schema";
+ * import { initG } from "@graphql-ts/schema";
  * import { GraphQLSchema, graphql } from "graphql";
  *
+ * type Context = {
+ *   loadPerson: (id: string) => Person;
+ *   loadFriends: (id: string) => Person[];
+ * };
+ * const g = initG<Context>();
+ * type g<T> = initG<T>;
+ *
+ * type Person = {
+ *   id: string;
+ *   name: string;
+ * };
+ *
+ * const Person: g<typeof g.object<Person>> = g.object<Person>()({
+ *   name: "Person",
+ *   fields: () => ({
+ *     id: g.field({ type: g.ID }),
+ *     name: g.field({ type: g.String }),
+ *     friends: g.field({
+ *       type: g.list(Person),
+ *       resolve(source, _, context) {
+ *         return context.loadFriends(source.id);
+ *       },
+ *     }),
+ *   }),
+ * });
+ *
  * const Query = g.object()({
  *   name: "Query",
  *   fields: {
- *     hello: g.field({
- *       type: g.String,
- *       resolve() {
- *         return "Hello!";
+ *     person: g.field({
+ *       type: Person,
+ *       args: {
+ *         id: g.arg({ type: g.ID }),
+ *       },
+ *       resolve(_, args, context) {
+ *         return context.loadPerson(args.id);
  *       },
  *     }),
  *   },
@@ -26,13 +55,37 @@
  *   query: Query,
  * });
  *
+ * const people = new Map<string, Person>([
+ *   ["1", { id: "1", name: "Alice" }],
+ *   ["2", { id: "2", name: "Bob" }],
+ * ]);
+ * const friends = new Map<string, string[]>([
+ *   ["1", ["2"]],
+ *   ["2", ["1"]],
+ * ]);
+ *
  * graphql({
  *   source: `
- *     query {
- *       hello
- *     }
- *   `,
+ *       query {
+ *         person(id: "1") {
+ *           id
+ *           name
+ *           friends {
+ *             id
+ *             name
+ *           }
+ *         }
+ *       }
+ *     `,
  *   schema,
+ *   context: {
+ *     loadPerson: (id) => people.get(id),
+ *     loadFriends: (id) => {
+ *       return (friends.get(id) ?? [])
+ *         .map((id) => people.get(id))
+ *         .filter((person) => person !== undefined);
+ *     },
+ *   },
  * }).then((result) => {
  *   console.log(result);
  * });
@@ -41,6 +94,7 @@
  * @module
  */
 export * as g from "./schema-api";
+export type g<T> = import("./output").initG<T>;
 export { initG, type GWithContext } from "./output";
 
 export type {

packages/schema/src/output.ts

@@ -599,6 +599,12 @@ export function initG<Context>(): typeof withoutContext &
   };
 }
 
+export type initG<T> = T extends () => (args: any) => infer R
+  ? R
+  : T extends (args: any) => infer R
+    ? R
+    : never;
+
 type Flatten<T> = {
   [Key in keyof T]: T[Key];
 } & {};

test-project/index.test-d.ts

@@ -2071,3 +2071,46 @@ const someInputFields = {
     Invariant<typeof a>
   >();
 }
+
+{
+  type Person = {
+    name: string;
+  };
+  const Person: g<typeof g.object<Person>> = g.object<Person>()({
+    name: "Person",
+    fields: () => ({
+      name: g.field({ type: g.String }),
+      friends: g.field({
+        type: g.list(Person),
+        resolve() {
+          return [];
+        },
+      }),
+    }),
+  });
+}
+
+{
+  type Context = { loadFriends: (id: string) => Promise<Person[]> };
+  const g = initG<Context>();
+  type g<T> = initG<T>;
+
+  type Person = {
+    id: string;
+    name: string;
+  };
+
+  const Person: g<typeof g.object<Person>> = g.object<Person>()({
+    name: "Person",
+    fields: () => ({
+      id: g.field({ type: g.ID }),
+      name: g.field({ type: g.String }),
+      friends: g.field({
+        type: g.list(Person),
+        resolve(source, _, context) {
+          return context.loadFriends(source.id);
+        },
+      }),
+    }),
+  });
+}