Importing providers with configurations without merging Query schemas

[gnz00]

Suppose you have a simple module with a provider that relies on an injected configuration:

// ProviderA.ts
import { Injectable, Inject } from "@graphql-modules/di"
import { ModuleConfig } from '@graphql-modules/core'
import "reflect-metadata"

@Injectable()
export class ProviderA {
    constructor(@Inject(ModuleConfig('module-a')) private config: Config) {}

    withIds(ids: string[]): String[] {
        return [];
    }
}

// ModuleA.ts
import { GraphQLModule, ModuleContext } from '@graphql-modules/core'
import { ProviderA } from './ProviderA'
import gql from 'graphql-tag'

export const ModuleA = new GraphQLModule<ModuleAConfig>({
    name: 'module-a',
    providers: () => [ProviderA],
    typeDefs: gql`
        type Query {
            people:(ids: [ID]!): [String]
        }
    `,
    resolvers: {
        Query: {
            people: (_, {ids}, {injector}: ModuleContext) => injector.get(ProviderA).withIds(ids)
        }
    }
})

And you try to create a higher order module that utilizes ProviderA:

// ModuleB.ts
import { GraphQLModule } from '@graphql-modules/core';
import { ModuleA, ModuleAConfig } from './ModuleA'

export interface ModuleBConfig {
    moduleA: ModuleAConfig
}

export const ModuleB = new GraphQLModule<ModuleBConfig>({
    name: 'module-b',
    imports: ({config}) => [ModuleA.forRoot(config.moduleA)],
    providers: () => [ProviderA],
    typeDefs: gql`
        type Query {
            composed(ids: [ID]!): [String]
        }
    `,
    resolvers: {
        Query: {
            composed: (_, {ids}, {injector}: ModuleContext) => {
                return injector.get(ProviderA).withIds(ids).map(
                    // transform...
                )
            }
        }
    }
})

With the above setup, composed and people will both be exposed as queries. Is there a way to only import the providers and pass them configuration?

[ardatan]

You can create a module that only has providers, and that module is imported by the other two modules so providers are shared by two modules without merging the schema.