Apollo Errors thrown in Resolver never reach the client

[exipnus]

Hi,

I have the following resolver method:

 @Mutation(() => UserOutput, { nullable: true })
 @UseMiddleware(TypegooseMiddleware)
  async signIn(
    @Arg('signInInput') { email, password }: SignInInput,
    @Ctx() ctx: IContext
  ): Promise<UserOutput | null> {
    await dbConnect();
    const existingUser = await this.userService.findByEmail(email);

    if (!existingUser) {
      throw new AuthenticationError(i18n?.t('auth:signinFailure')!);
    }

    const passwordsMatch = await PasswordService.compare(
      existingUser.password,
      password
    );

    if (!passwordsMatch) {
      throw new AuthenticationError(i18n?.t('auth:signinFailure')!);
    }

    const cookie = getCookieWithJwtToken(existingUser._id.toString());
    ctx.res.setHeader('Set-Cookie', cookie);

    return mapper.map(existingUser, UserOutput, User);
  }

and my server setup is:

import 'reflect-metadata';
// Add Mappings
import './lib/mappings';

import { ApolloServer } from 'apollo-server-micro';
import { GraphQLSchema } from 'graphql';
import { ObjectId } from 'mongodb';
import { PageConfig } from 'next';
import { NonEmptyArray } from 'type-graphql';
import { buildSchema } from 'type-graphql/dist/utils';
import { Container } from 'typedi';

import { authChecker, ObjectIdScalar } from './lib';
import {
  AccommodationResolver,
  AmenityResolver,
  AuthResolver,
  CategoryResolver,
  CountryResolver,
  FacilityResolver,
  PackageResolver,
  UserResolver,
} from './resolvers';

if (!process.env.QUERY_COMPLEXITY) {
  throw new Error('QUERY_COMPLEXITY must be defined');
}

const resolvers = [
  AuthResolver,
  UserResolver,
  AccommodationResolver,
  AmenityResolver,
  FacilityResolver,
  CategoryResolver,
  CountryResolver,
  PackageResolver,
] as NonEmptyArray<Function> | NonEmptyArray<string>;

const prepareSchema = async (): Promise<GraphQLSchema> => {
  const schema = await buildSchema({
    resolvers,
    scalarsMap: [{ type: ObjectId, scalar: ObjectIdScalar }],
    emitSchemaFile: true,
    authChecker,
    // register the 3rd party IOC container
    container: Container,
  });

  return schema;
};

const apolloServer = new ApolloServer({
  schema: await prepareSchema(),
  context: async ({ req, res }) => {
    return {
      req,
      res,
    };
  },
});

await apolloServer.start().catch((error) => console.log(error));

The Authentication error thrown inside the signIn resolver method never reaches my client. If I throw the same errors from a Middleware/Guard using @UserMiddleware() decorator the error reaches client-side. I'd like to be able to throw ApolloError from inside my resolver methods and see them propagate to my client (see https://www.apollographql.com/docs/apollo-server/data/errors)

Am I doing something wrong?

Thank you

[exipnus]

I finally found that I was using another middleware (TypegooseMiddleware) that was swallowing my errors.

So now everything works ok.