@nestjs/graphql
Version:
GraphQL for NestJS: code-first and schema-first APIs, resolvers as providers, subscriptions, federation and generated SDL, on Apollo or Mercurius.
196 lines (195 loc) • 9.61 kB
JavaScript
var GraphQLFactory_1;
import { __decorate, __metadata } from "tslib";
import { mergeResolvers } from '@graphql-tools/merge';
import { makeExecutableSchema, mergeSchemas } from '@graphql-tools/schema';
import { getResolversFromSchema } from '@graphql-tools/utils';
import { Injectable, Logger } from '@nestjs/common';
import { existsSync, lstatSync, readFileSync } from 'fs';
import { GraphQLSchema, isObjectType, lexicographicSortSchema, printSchema, } from 'graphql';
import { gql } from 'graphql-tag';
import { GraphQLAstExplorer, } from './graphql-ast.explorer.js';
import { GraphQLSchemaBuilder } from './graphql-schema.builder.js';
import { ResolversExplorerService, ScalarsExplorerService, } from './services/index.js';
import { extend, removeTempField } from './utils/index.js';
import { createFieldResolverBinder, inheritResolversFromInterfaces, } from './utils/resolver-binding.util.js';
let GraphQLFactory = GraphQLFactory_1 = class GraphQLFactory {
constructor(resolversExplorerService, scalarsExplorerService, graphqlAstExplorer, gqlSchemaBuilder) {
this.resolversExplorerService = resolversExplorerService;
this.scalarsExplorerService = scalarsExplorerService;
this.graphqlAstExplorer = graphqlAstExplorer;
this.gqlSchemaBuilder = gqlSchemaBuilder;
this.logger = new Logger(GraphQLFactory_1.name);
}
async generateSchema(options = { typeDefs: [] }) {
if (options.directiveResolvers) {
this.logger.warn('The "directiveResolvers" option is ignored (it has had no effect since v9.2.0): the directive resolvers passed through it are never called. Apply the directives with "transformSchema" instead (for example, with "mapSchema()" from "@graphql-tools/utils").');
}
const resolvers = this.resolversExplorerService.explore();
const rawResolvers = extend(this.scalarsExplorerService.explore(), resolvers);
const typesResolvers = options.transformResolvers
? await options.transformResolvers(rawResolvers)
: rawResolvers;
/**
* Merge field by field, so that an entry of the "resolvers" option does
* not replace the field resolvers discovered for the same type
*/
const executableResolvers = mergeResolvers([typesResolvers, options.resolvers].flat());
const transformSchema = async (schema) => options.transformSchema ? await options.transformSchema(schema) : schema;
if (options.autoSchemaFile) {
const autoGeneratedSchema = await this.gqlSchemaBuilder.build(options.autoSchemaFile, options, this.resolversExplorerService.getAllCtors());
const executableSchema = makeExecutableSchema({
resolvers: executableResolvers,
typeDefs: gql `
${printSchema(autoGeneratedSchema)}
`,
resolverValidationOptions: {
...(options.resolverValidationOptions || {}),
requireResolversForResolveType: 'ignore',
},
inheritResolversFromInterfaces: options.inheritResolversFromInterfaces,
});
let schema = options.schema
? mergeSchemas({
schemas: [options.schema, executableSchema],
})
: executableSchema;
const autoGeneratedSchemaConfig = autoGeneratedSchema.toConfig();
const schemaConfig = this.overrideOrExtendResolvers(schema.toConfig(), autoGeneratedSchemaConfig, executableSchema, executableResolvers, options.buildSchemaOptions?.fieldMiddleware ?? []);
schema = new GraphQLSchema(schemaConfig);
schema = await transformSchema(schema);
schema = options.sortSchema ? lexicographicSortSchema(schema) : schema;
return schema;
}
if (this.isEmptyValue(options.typeDefs)) {
const schema = await transformSchema(options.schema);
return schema;
}
const executableSchemaConfig = {
resolvers: executableResolvers,
typeDefs: gql `
${options.typeDefs}
`,
resolverValidationOptions: options.resolverValidationOptions,
inheritResolversFromInterfaces: options.inheritResolversFromInterfaces,
};
/**
* Merge the type definitions themselves (rather than a schema made
* executable from them) into the "schema" option, so that a scalar or an
* enum that both declare keeps the implementation of the "schema" option,
* unless one is registered on the Nest side
*/
let schema = options.schema
? mergeSchemas({
schemas: [options.schema],
...executableSchemaConfig,
})
: makeExecutableSchema(executableSchemaConfig);
if (options.inheritResolversFromInterfaces) {
inheritResolversFromInterfaces(schema, options.schema
? mergeResolvers([
getResolversFromSchema(options.schema),
executableResolvers,
])
: executableResolvers);
}
removeTempField(schema);
schema = await transformSchema(schema);
schema = options.sortSchema ? lexicographicSortSchema(schema) : schema;
return schema;
}
overrideOrExtendResolvers(executableSchemaConfig, autoGeneratedSchemaConfig, executableSchema, resolvers, globalMiddleware) {
const schemaConfig = autoGeneratedSchemaConfig;
const rootResolverKeys = [
'mutation',
'query',
'subscription',
];
rootResolverKeys
.filter((key) => executableSchemaConfig[key] && schemaConfig[key])
.forEach((key) => {
const executableSchemaFields = executableSchemaConfig[key].getFields();
const schemaFields = schemaConfig[key].getFields();
Object.entries(executableSchemaFields).forEach(([resolverName, value]) => {
if (schemaFields[resolverName]) {
schemaFields[resolverName].resolve =
executableSchemaFields[resolverName].resolve;
schemaFields[resolverName].subscribe =
executableSchemaFields[resolverName].subscribe;
}
else {
schemaFields[resolverName] = value;
}
});
});
const rootTypes = new Set(rootResolverKeys.map((key) => schemaConfig[key]).filter(Boolean));
const typesByName = new Map(schemaConfig.types.map((type) => [type.name, type]));
const mergedTypesByName = new Map(executableSchemaConfig.types.map((type) => [type.name, type]));
const binder = createFieldResolverBinder({
executableSchema,
resolvers,
getType: (typeName) => typesByName.get(typeName),
globalMiddleware,
});
schemaConfig.types
.filter(isObjectType)
.filter((type) => !rootTypes.has(type))
.forEach((type) => {
const mergedType = mergedTypesByName.get(type.name);
Object.entries(type.getFields()).forEach(([fieldName, field]) => {
const resolve = binder.getFieldResolver(type.name, fieldName,
/**
* Keep the resolvers of the "schema" option for a type of the same name
*/
() => isObjectType(mergedType) &&
mergedType !== executableSchema.getType(type.name)
? mergedType.getFields()[fieldName]?.resolve
: undefined);
if (resolve) {
field.resolve = resolve;
}
});
});
binder.warnUnboundFields(this.logger);
return schemaConfig;
}
async generateDefinitions(typeDefs, options) {
if (this.isEmptyValue(typeDefs) || !options.definitions) {
return;
}
const definitionsGeneratorOptions = {
emitTypenameField: options.definitions.emitTypenameField,
skipResolverArgs: options.definitions.skipResolverArgs,
defaultScalarType: options.definitions.defaultScalarType,
customScalarTypeMapping: options.definitions.customScalarTypeMapping,
additionalHeader: options.definitions.additionalHeader,
defaultTypeMapping: options.definitions.defaultTypeMapping,
enumsAsTypes: options.definitions.enumsAsTypes,
typeName: options.definitions.typeName,
};
const tsFile = await this.graphqlAstExplorer.explore(gql `
${typeDefs}
`, options.definitions.path, options.definitions.outputAs, definitionsGeneratorOptions);
if (!existsSync(options.definitions.path) ||
!lstatSync(options.definitions.path).isFile() ||
readFileSync(options.definitions.path, 'utf8') !== tsFile.getFullText()) {
await tsFile.save();
}
}
isEmptyValue(value) {
if (value == null) {
return true;
}
if (Array.isArray(value) || typeof value === 'string') {
return value.length === 0;
}
return false;
}
};
GraphQLFactory = GraphQLFactory_1 = __decorate([
Injectable(),
__metadata("design:paramtypes", [ResolversExplorerService,
ScalarsExplorerService,
GraphQLAstExplorer,
GraphQLSchemaBuilder])
], GraphQLFactory);
export { GraphQLFactory };