[typescript-resolvers] How to define a defaultMapper generic that allows more type-safety / autocompletion on the resolver while allowing other fields to be used.

[strazto]

The problem

I have a lot of resolvers already implemented, with data models that don't yet have types implemented.

I'm looking to incrementally improve the type safety, type inference and IDE auto-completion for my resolvers, but don't wish to implement every single mapper just yet.

Current any escape hatch workaround

Presently, I've gotten around this using any as the default mapper:

import type { CodegenConfig } from '@graphql-codegen/cli';

// TODO: This doesn't work as defaultMapper
//       but might work for some kind of parent type default instead
//       instead of using `any` for default mapper
// ~ https://the-guild.dev/blog/better-type-safety-for-resolvers-with-graphql-codegen
// ~ https://github.com/dotansimha/graphql-code-generator/issues/1133#issuecomment-456812621
interface StringIndexSignatureInterface {
  [index: string]: any
}
export type StringIndexed<T> = T & StringIndexSignatureInterface

const config: CodegenConfig = {
  schema: 'src/**/{S,s}chema.ts',
  generates: {
    'src/__generated/resolvers-types.ts': {
      config: {
        useIndexSignature: true,
        // There's a better base replacement for sure, but this is ok for now.
        defaultMapper: 'any',
       // defaultMapper: '../schema#StringIndexed<{T}>',
      },
      plugins: [
        'typescript',
        'typescript-resolvers',
      ],
    },
  },
};
export default config;

For now, the hammer of any lets me use the generated fields for type-safety for the arguments of my resolvers, like so:

I think this is still an improvement on what I previously had.

But this use of any clobbers type inference for my parent objects & resolvers a little more than I'd like.

A more elegant solution I'd like

Ideally, I'd like to be able to use generics to refer to fields from the generated types, as well as union this with some fields that are common to any entry in my db (eg, _key, _id, etc), and then fall back to any, or maybe unknown or never for fields that dont match this.

TL;DR

Can anyone recommend a pattern / generic that lets me has a decent defaultMapper, ideally unioning something like:

T & { [k: string]: any} & { _key: string; _id: string; /* etc */ }

while allowing me to add better mapper types incrementally?

What I've been able to find so far

From the docs typescript-resolvers#wrap-default-types-with-partial, I know I can use generics for my types, and from this guide: Better Type Safety for your GraphQL resolvers with GraphQL Codegen, I'm given a reference for how I might use Partial generics.

That blog posts links the following issue comment, on the topic of "default mappers": #1133 (comment),

The common essentially demonstrates using a union between the given type parameter, and a generic string indexed object, to allow some type inference & autocomplete for fields that should be resolved, while allowing reference to fields present on the model but not on the parent type.

The problem, however, is that If I change my config like so:

// codegen.ts
import type { CodegenConfig } from '@graphql-codegen/cli';

const config: CodegenConfig = {
  schema: 'src/**/{S,s}chema.ts',
  generates: {
    'src/__generated/resolvers-types.ts': {
      config: {
        useIndexSignature: true,
        // Try to use defaultMapper that leverages generics
        defaultMapper: '../schema#StringIndexed<{T}>',
      },
      plugins: [
        'typescript',
        'typescript-resolvers',
      ],
    },
  },
};
export default config;

With the demo'd StringIndexed generic:

// ~ https://the-guild.dev/blog/better-type-safety-for-resolvers-with-graphql-codegen
// ~ https://github.com/dotansimha/graphql-code-generator/issues/1133#issuecomment-456812621
interface StringIndexSignatureInterface {
    [index: string]: any
  }
export type StringIndexed<T> = T & StringIndexSignatureInterface

I get errors on my resolvers, particularly in the instances where the field being referenced comes from the generated parent type, as in:

[simplecommerce]

@strazto Hi, did you end up finding a solution to your issue?

[strazto]

I think I might have worked something out, I'll try to get back to you

[simplecommerce]

I think I got a way to get it working on my end.

import { Primitive } from "type-fest";

/**
 * A type that conditionally maps the type `T`. If `T` is a primitive type (e.g., `string`, `number`, `boolean`, `bigint`, `symbol`, `undefined`, `null`), it simply returns `T` itself, preserving the primitive type.
 *
 * If `T` is not a primitive, it performs two operations:
 * 1. It retains the structure of `T`, mapping each property `K` of `T` to its corresponding type `T[K]`. This ensures that the original shape of `T` is maintained.
 * 2. It extends the resulting type with an index signature `[x: string]: unknown`, which allows it to have any number of additional string properties not explicitly defined in `T`, with their types being `unknown`. This makes the type flexible, allowing for properties beyond those initially declared.
 * @template T - The type variable that `DefaultMapper` operates on. Depending on whether `T` is a primitive or an object, the resulting type will either be `T` itself (for primitives) or an extended object type (for non-primitives).
 */
export type DefaultMapper<T> = T extends Primitive ? T : {
	[K in keyof T]: T[K]
} & {
	[x: string]: unknown
}

I used this as my defaultMapper and it seems to work for my resolver chains.

Don't know if its the "right" way to do it.