[TypeScript] Ensure all queries are implemented

[SimonSimCity]

I'm working using a schema-first approach and was asking myself how I can ensure all queries, mentioned in the graphql interface, are implemented. If you have a way, please share it, here's mine:

My graphql I organised in groups which I call modules. Here's an example of the module main:

// ./modules/main/query.ts
const queryResolver: Required<Pick<QueryResolvers, "hello">> =
  {
    hello: (_, { name }) => `Hello ${name}!`
  }

export default queryResolver;

// ./modules/main/resolvers.ts
import queryResolver from "./query";

export const query = queryResolver;

All modules are now put together in a collective resolvers-file:

// ./modules/resolvers.ts
import { query as mainQuery } from "./main/resolvers";

export const query = {
  ...mainQuery,
};
export const mutation = {};
export const type = {};

This allows me to write the queries I want to implement in this file ("hello" and maybe others as well) and use the generated types. I'll also be informed if this query does not exist anymore, in which case I'd get an ESLint error on the Pick<T, P> type definition, because the properties must exist on the type.

All this is good and nicely provided by the generated types of this library. Now to the part where I struggled:

When I merge the modules together and try to find out which queries are defined in the graphql files but not yet implemented, I couldn't find any type I could use there. If there is, please let me know! This is how I defined my own types to ensure every type is resolvable and every query is defined. These type definitions should work independently of if optionalResolveType is en- or disabled:

import { GraphQLScalarType } from "graphql";
import { ApolloServer } from "apollo-server-azure-functions";
import {
  ApolloServerPluginLandingPageDisabled,
  Config,
} from "apollo-server-core";
import { loadFiles } from "graphql-import-files";
import { makeExecutableSchema } from "@graphql-tools/schema";

import { query, mutation, type } from "./modules/resolvers";
import { Resolvers } from "../generated/graphql";

type NestedRequired<T> = {
  [P in keyof T]-?: Required<T[P]>;
};

// List of type resolvers which require type-resolving. Not necessary if optionalResolveType is enabled.
type KeysOfGraphqlResolveTypes<T extends object> = {
  [K in keyof T]-?: Required<T>[K] extends { __resolveType: unknown }
    ? K
    : never;
}[keyof T];

// List resolvers not having optional "__isTypeOf", extend GraphQLScalarType or have "__resolveType".
// Those types are special graphql-properties we need to have nestedly required to ensure all graphql-actions are covered.
type KeysOfGraphqlEntryPoints<T extends object> = {
  [K in keyof T]-?: Required<Required<T>[K]> extends {
    __isTypeOf: unknown;
  }
    ? never
    : Required<T>[K] extends GraphQLScalarType
    ? never
    : Required<Required<T>[K]> extends { __resolveType: unknown } // Needs to be wrapped it into require twice if optionalResolveType is set to true
    ? never
    : K;
}[keyof T];

type GraphQLResolvers = Required<
  // All types requiring a resolver must have one defined.
  Pick<Resolvers, KeysOfGraphqlResolveTypes<Resolvers>>
> &
  // The entry points to GraphQL need a nested "require" to ensure every property is defined (https://graphql.org/learn/schema/#the-query-and-mutation-types)
  NestedRequired<Pick<Resolvers, KeysOfGraphqlEntryPoints<Resolvers>>>;

// Construct a schema, using GraphQL schema language
const typeDefs = loadFiles("schema/**/*.{graphql,gql}");

// Provide resolver functions for your schema fields
const resolvers: GraphQLResolvers = {
  Query: {
    ...query,
  },
  Mutation: {
    ...mutation,
  },
};

let schema = makeExecutableSchema({
  typeDefs,
  resolvers,
});

const apolloConfig: Config = {
  schema,
  plugins: [ApolloServerPluginLandingPageDisabled()],
  introspection: process.env.NODE_ENV !== "production",
};

export const server = new ApolloServer(apolloConfig);

export const run = server.createHandler();

If there is an easier way, please let me know! If this is a good way of solving this problem, it would be nice if either those types would be implemented in the generated file or if it could be added to a best-practice section or something ...