Easier context binding with instantiation expressions

[emmatown]

This is an alternative to #41 attempting to solve the same problem.

Instead of the big type definition of g, g is defined as "get the return type of the function but if the function takes no arguments and the function returns a function that does take arguments, get the return type of that function". So this can be used with the functions like g.object + instantiation expressions. This is definitely a much neater design than #40 and nicely has less API going on but it has some problems:

• Defining circular input object types does not work (this is the main problem)
• This doesn't include something to easily get the types like OutputType/etc.
• If defining circular input object types did work, the extra typeof and g. and <...> syntax clutter up definitions a lot

While these problems aren't great, I think they're probably the right trade-offs and for cases where g<typeof g.something<...>> don't work, people can use the exports from @graphql-ts/schema especially since those cases are much more advanced use cases.

Here's the same example as in #41 but using this

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<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.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);
      },
    }),
  }),
});

[socket-security]

Updated dependencies detected. Learn more about Socket for GitHub ↗︎

Package	New capabilities	Transitives	Size	Publisher
npm/@types/node@22.10.10 ➜ 22.13.10	None	+1	2.4 MB	types

View full report↗︎