Easier context binding

Author: emmatown

packages/schema/README.md

@@ -6,16 +6,49 @@ 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 | undefined;
+  loadFriends: (id: string) => Person[];
+};
+const g = initG<Context>();
+type g<
+  Key extends initG.Key,
+  Arg extends initG.Arg[Key] = initG.ArgDefaults[Key],
+  OtherArg extends initG.OtherArg[Key] = initG.OtherArgDefaults<Arg>[Key],
+> = initG<Context, Key, Arg, OtherArg>;
+
+type Person = {
+  id: string;
+  name: string;
+};
+
+const Person: g<"object", Person> = g.object<Person>()({
+  name: "Person",
+  fields: () => ({
+    id: g.field({ type: g.nonNull(g.ID) }),
+    name: g.field({ type: g.nonNull(g.String) }),
+    friends: g.field({
+      type: g.list(g.nonNull(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.nonNull(g.ID) }),
+      },
+      resolve(_, args, context) {
+        return context.loadPerson(args.id);
       },
     }),
   },
@@ -25,14 +58,40 @@ const schema = new GraphQLSchema({
   query: Query,
 });
 
-graphql({
-  source: `
-    query {
-      hello
-    }
-  `,
-  schema,
-}).then((result) => {
-  console.log(result);
-});
+{
+  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"]],
+  ]);
+  const contextValue: Context = {
+    loadPerson: (id) => people.get(id),
+    loadFriends: (id) => {
+      return (friends.get(id) ?? [])
+        .map((id) => people.get(id))
+        .filter((person) => person !== undefined) as Person[];
+    },
+  };
+  graphql({
+    source: `
+      query {
+        person(id: "1") {
+          id
+          name
+          friends {
+            id
+            name
+          }
+        }
+      }
+    `,
+    schema,
+    contextValue,
+  }).then((result) => {
+    console.log(result);
+  });
+}
 ```

packages/schema/src/index.ts

@@ -7,16 +7,50 @@
  * [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 | undefined;
+ *   loadFriends: (id: string) => Person[];
+ * };
+ * const g = initG<Context>();
+ * type g<
+ *   Key extends initG.Key,
+ *   Arg extends initG.Arg[Key] = initG.ArgDefaults[Key],
+ *   OtherArg extends
+ *     initG.OtherArg[Key] = initG.OtherArgDefaults<Arg>[Key],
+ * > = initG<Context, Key, Arg, OtherArg>;
+ *
+ * type Person = {
+ *   id: string;
+ *   name: string;
+ * };
+ *
+ * const Person: g<"object", Person> = g.object<Person>()({
+ *   name: "Person",
+ *   fields: () => ({
+ *     id: g.field({ type: g.nonNull(g.ID) }),
+ *     name: g.field({ type: g.nonNull(g.String) }),
+ *     friends: g.field({
+ *       type: g.list(g.nonNull(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.nonNull(g.ID) }),
+ *       },
+ *       resolve(_, args, context) {
+ *         return context.loadPerson(args.id);
  *       },
  *     }),
  *   },
@@ -26,21 +60,52 @@
  *   query: Query,
  * });
  *
- * graphql({
- *   source: `
- *     query {
- *       hello
- *     }
- *   `,
- *   schema,
- * }).then((result) => {
- *   console.log(result);
- * });
+ * {
+ *   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"]],
+ *   ]);
+ *   const contextValue: Context = {
+ *     loadPerson: (id) => people.get(id),
+ *     loadFriends: (id) => {
+ *       return (friends.get(id) ?? [])
+ *         .map((id) => people.get(id))
+ *         .filter((person) => person !== undefined) as Person[];
+ *     },
+ *   };
+ *   graphql({
+ *     source: `
+ *       query {
+ *         person(id: "1") {
+ *           id
+ *           name
+ *           friends {
+ *             id
+ *             name
+ *           }
+ *         }
+ *       }
+ *     `,
+ *     schema,
+ *     contextValue,
+ *   }).then((result) => {
+ *     console.log(result);
+ *   });
+ * }
  * ```
  *
  * @module
  */
 export * as g from "./schema-api";
+export type g<
+  Key extends initG.Key,
+  FirstArg extends initG.Arg[Key] = initG.ArgDefaults[Key],
+  SecondArg extends initG.OtherArg[Key] = initG.OtherArgDefaults<FirstArg>[Key],
+> = initG<unknown, Key, FirstArg, SecondArg>;
 export { initG, type GWithContext } from "./output";
 
 export {
@@ -78,6 +143,7 @@ export type {
   ScalarType,
 } from "./api-without-context";
 
+import { initG } from "./output";
 import type {
   GArg,
   GField,