TypeGraphQL：使用从本地 Package 导入的 GraphQL class 时出现@Arg 类型错误

Question

I have created a local package with several objects. this package is aimed to be installed via npm in other programs in order to benefit from a common librairy of objects. Among them, I have created a simple class to create a AppoloServer, to be used with TypeGraphQL entities, types and resolvers:

export class ClsApolloGraphQlServer {
    private _resolvers: any[];
    private _connection: Connection;

    constructor(
        resolvers: any[],
        connection: Connection,
    ) {
        this._resolvers = resolvers;
        this._connection = connection;
    }

    public async initApolloServer(
        app: express.Application,
        corsOpt: cors.CorsOptions
    ): Promise<ApolloServer> {
            const {
                typeDefs,
                resolvers,
            } = await buildTypeDefsAndResolvers({
                resolvers: this._resolvers,
            });

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

            addSchemaLevelResolveFunction(
                schema,
                (_, __, context) =>
                    !!getSession(context, this._SESSION_TYPE)
            );

            const apolloServer: ApolloServer = new ApolloServer({
                schema,
                context: ({
                    req,
                    res,
                }: {
                    req: Request;
                    res: Response;
                }): IGlobalContext => {
                    return {
                        req,
                        res,
                        dbConnection: this._connection,
                    };
                },
                formatError: (err: GraphQLError) =>
                    FormatErrorMessageGraphQlServer(err),
            });

            apolloServer.applyMiddleware({ app, cors: corsOpt });

            return apolloServer;

    }
}

Duplicating this code in one of the final program and importing the class from this final program works fine.

However, importing the class in the final program after installing the common library makes TypeGraphQL failing with the error " Cannot determine GraphQL input type for start ".

Below is an example of the resolver that is falling and the type defined for Arg, since 'start' is an argument of resolvers to manage pagination.

Don't know what is wrong. Just mentionning that I'm importing 'reflect-metadata' in the class Definition file in the librairy, and also at the very beginning of the final program.

Resolver

@Query(() => [objectTypeCls], { name: `getAll${suffix}` })
        async getAll(
            @Ctx() context: IGlobalContext,
            @Args() { start, nbRecords }: PaginationArgs
        ): Promise<TExposeApi[]> {

            if (context.dbConnection && context.dbConnection.isConnected) {
                const resu: TExposeApi[] = await context.dbConnection
                    .getRepository<TExposeApi>(objectTypeCls)
                    .createQueryBuilder(suffix)
                    .skip(start)
                    .take(nbRecords)
                    .getMany();
                return resu;
            } else return [];
        }

ArgType

@ArgsType()
export class PaginationArgs {
    @Field(() => Int)
    start: number;

    @Field(() => Int)
    nbRecords: number;
}

Answer 1

You have to use package repository for bundled artifacts or a lerna monorepo with dependencies hoisting. In your case you just linking the packages but they have separated graphql package in their node_modules, which raises a conflict where Int !== Int between graphql packages instances.