[typescript-resolver-files] Add e2e coverage for unresolvable mapper types

.changeset/tricky-mappers-warn.md

@@ -1,5 +1,5 @@
 ---
-'@eddeee888/gcg-typescript-resolver-files': patch
+'@eddeee888/gcg-typescript-resolver-files': minor
 ---
 
 Fix `fixObjectTypeResolvers` treating an unresolvable mapper type as an empty mapper and injecting a stub for every field

packages/typescript-resolver-files-e2e/src/test-mappers-vs-schema-types-advanced/modules/resolvers.generated.ts

@@ -2,11 +2,15 @@
     import type   { Resolvers } from './types.generated';
     import    { user as Query_user } from './test/resolvers/Query/user';
 import    { Book } from './test/resolvers/Book';
+import    { MappedResolveEmptyObject } from './test/resolvers/MappedResolveEmptyObject';
+import    { MappedResolveError } from './test/resolvers/MappedResolveError';
 import    { User } from './test/resolvers/User';
     export const resolvers: Resolvers = {
       Query: { user: Query_user },
 
 
       Book: Book,
+MappedResolveEmptyObject: MappedResolveEmptyObject,
+MappedResolveError: MappedResolveError,
 User: User
     }

packages/typescript-resolver-files-e2e/src/test-mappers-vs-schema-types-advanced/modules/test/resolvers/MappedResolveEmptyObject.ts

@@ -0,0 +1,15 @@
+import type   { MappedResolveEmptyObjectResolvers } from './../../types.generated';
+    /*
+    * Note: This object type is generated because "MappedResolveEmptyObjectMapper" is declared. This is to ensure runtime safety.
+    *
+    * When a mapper is used, it is possible to hit runtime errors in some scenarios:
+    * - given a field name, the schema type's field type does not match mapper's field type
+    * - or a schema type's field does not exist in the mapper's fields
+    *
+    * If you want to skip this file generation, remove the mapper or update the pattern in the `resolverGeneration.object` config.
+    */
+export const MappedResolveEmptyObject: MappedResolveEmptyObjectResolvers = {
+    /* Implement MappedResolveEmptyObject resolver logic here */
+    field: async (_parent, _arg, _ctx) => { /* MappedResolveEmptyObject.field resolver is required because MappedResolveEmptyObject.field exists but MappedResolveEmptyObjectMapper.field does not */ },
+    id: async (_parent, _arg, _ctx) => { /* MappedResolveEmptyObject.id resolver is required because MappedResolveEmptyObject.id exists but MappedResolveEmptyObjectMapper.id does not */ }
+};

packages/typescript-resolver-files-e2e/src/test-mappers-vs-schema-types-advanced/modules/test/resolvers/MappedResolveError.ts

@@ -0,0 +1,13 @@
+import type   { MappedResolveErrorResolvers } from './../../types.generated';
+    /*
+    * Note: This object type is generated because "MappedResolveErrorMapper" is declared. This is to ensure runtime safety.
+    *
+    * When a mapper is used, it is possible to hit runtime errors in some scenarios:
+    * - given a field name, the schema type's field type does not match mapper's field type
+    * - or a schema type's field does not exist in the mapper's fields
+    *
+    * If you want to skip this file generation, remove the mapper or update the pattern in the `resolverGeneration.object` config.
+    */
+export const MappedResolveError: MappedResolveErrorResolvers = {
+    /* Implement MappedResolveError resolver logic here */
+  };

packages/typescript-resolver-files-e2e/src/test-mappers-vs-schema-types-advanced/modules/test/schema.graphqls

@@ -39,6 +39,16 @@ type Book {
   nextBookInSeries: Book!
 }
 
+type MappedResolveEmptyObject {
+  id: ID!
+  field: String!
+}
+
+type MappedResolveError {
+  id: ID!
+  field: String!
+}
+
 type NotMapped {
   id: ID!
 }

packages/typescript-resolver-files-e2e/src/test-mappers-vs-schema-types-advanced/modules/test/schema.mappers.ts

@@ -1,3 +1,6 @@
+export type { MappedResolveErrorMapper } from 'does-not-exist';
+export type MappedResolveEmptyObjectMapper = {};
+
 export type UserMapper = {
   id: number;
 

packages/typescript-resolver-files-e2e/src/test-mappers-vs-schema-types-advanced/modules/types.generated.ts

@@ -1,5 +1,5 @@
 import { GraphQLResolveInfo } from 'graphql';
-import { BookMapper, UserMapper } from './test/schema.mappers';
+import { BookMapper, MappedResolveEmptyObjectMapper, MappedResolveErrorMapper, UserMapper } from './test/schema.mappers';
 export type Maybe<T> = T | null | undefined;
 export type InputMaybe<T> = T | null | undefined;
 /** All built-in and custom scalars, mapped to their actual values */
@@ -19,6 +19,18 @@ export type Book = {
   relatedBooks: Array<Book>;
 };
 
+export type MappedResolveEmptyObject = {
+  __typename?: 'MappedResolveEmptyObject';
+  field: Scalars['String']['output'];
+  id: Scalars['ID']['output'];
+};
+
+export type MappedResolveError = {
+  __typename?: 'MappedResolveError';
+  field: Scalars['String']['output'];
+  id: Scalars['ID']['output'];
+};
+
 export type NotMapped = {
   __typename?: 'NotMapped';
   id: Scalars['ID']['output'];
@@ -127,6 +139,8 @@ export type ResolversTypes = {
   Book: ResolverTypeWrapper<BookMapper>;
   ID: ResolverTypeWrapper<Scalars['ID']['output']>;
   String: ResolverTypeWrapper<Scalars['String']['output']>;
+  MappedResolveEmptyObject: ResolverTypeWrapper<MappedResolveEmptyObjectMapper>;
+  MappedResolveError: ResolverTypeWrapper<MappedResolveErrorMapper>;
   NotMapped: ResolverTypeWrapper<NotMapped>;
   Query: ResolverTypeWrapper<Record<PropertyKey, never>>;
   User: ResolverTypeWrapper<UserMapper>;
@@ -138,6 +152,8 @@ export type ResolversParentTypes = {
   Book: BookMapper;
   ID: Scalars['ID']['output'];
   String: Scalars['String']['output'];
+  MappedResolveEmptyObject: MappedResolveEmptyObjectMapper;
+  MappedResolveError: MappedResolveErrorMapper;
   NotMapped: NotMapped;
   Query: Record<PropertyKey, never>;
   User: UserMapper;
@@ -151,6 +167,16 @@ export type BookResolvers<ContextType = any, ParentType extends ResolversParentT
   relatedBooks?: Resolver<Array<ResolversTypes['Book']>, ParentType, ContextType>;
 };
 
+export type MappedResolveEmptyObjectResolvers<ContextType = any, ParentType extends ResolversParentTypes['MappedResolveEmptyObject'] = ResolversParentTypes['MappedResolveEmptyObject']> = {
+  field?: Resolver<ResolversTypes['String'], ParentType, ContextType>;
+  id?: Resolver<ResolversTypes['ID'], ParentType, ContextType>;
+};
+
+export type MappedResolveErrorResolvers<ContextType = any, ParentType extends ResolversParentTypes['MappedResolveError'] = ResolversParentTypes['MappedResolveError']> = {
+  field?: Resolver<ResolversTypes['String'], ParentType, ContextType>;
+  id?: Resolver<ResolversTypes['ID'], ParentType, ContextType>;
+};
+
 export type NotMappedResolvers<ContextType = any, ParentType extends ResolversParentTypes['NotMapped'] = ResolversParentTypes['NotMapped']> = {
   id?: Resolver<ResolversTypes['ID'], ParentType, ContextType>;
 };
@@ -182,6 +208,8 @@ export type UserResolvers<ContextType = any, ParentType extends ResolversParentT
 
 export type Resolvers<ContextType = any> = {
   Book?: BookResolvers<ContextType>;
+  MappedResolveEmptyObject?: MappedResolveEmptyObjectResolvers<ContextType>;
+  MappedResolveError?: MappedResolveErrorResolvers<ContextType>;
   NotMapped?: NotMappedResolvers<ContextType>;
   Query?: QueryResolvers<ContextType>;
   User?: UserResolvers<ContextType>;