@nestjs/graphql/dist/schema-builder/graphql-schema.factory.js

Nest - modern, fast, powerful node.js web framework (@graphql)

var GraphQLSchemaFactory_1;
import { __decorate, __metadata } from "tslib";
import { Injectable, Logger } from '@nestjs/common';
import { isEmpty, isFunction } from '@nestjs/common/utils/shared.utils.js';
import { getIntrospectionQuery, graphql, GraphQLSchema, specifiedDirectives, } from 'graphql';
import { SCALAR_NAME_METADATA, SCALAR_TYPE_METADATA, } from '../graphql.constants.js';
import { createScalarType } from '../utils/scalar-types.utils.js';
import { SchemaGenerationError } from './errors/schema-generation.error.js';
import { MutationTypeFactory } from './factories/mutation-type.factory.js';
import { OrphanedTypesFactory } from './factories/orphaned-types.factory.js';
import { QueryTypeFactory } from './factories/query-type.factory.js';
import { SubscriptionTypeFactory } from './factories/subscription-type.factory.js';
import { LazyMetadataStorage } from './storages/lazy-metadata.storage.js';
import { TypeMetadataStorage } from './storages/type-metadata.storage.js';
import { TypeDefinitionsGenerator } from './type-definitions.generator.js';
let GraphQLSchemaFactory = GraphQLSchemaFactory_1 = class GraphQLSchemaFactory {
    constructor(queryTypeFactory, mutationTypeFactory, subscriptionTypeFactory, orphanedTypesFactory, typeDefinitionsGenerator) {
        this.queryTypeFactory = queryTypeFactory;
        this.mutationTypeFactory = mutationTypeFactory;
        this.subscriptionTypeFactory = subscriptionTypeFactory;
        this.orphanedTypesFactory = orphanedTypesFactory;
        this.typeDefinitionsGenerator = typeDefinitionsGenerator;
        this.logger = new Logger(GraphQLSchemaFactory_1.name);
    }
    async create(resolvers, scalarsOrOptions = [], options = {}) {
        if (Array.isArray(scalarsOrOptions)) {
            this.assignScalarObjects(scalarsOrOptions, options);
        }
        else {
            options = scalarsOrOptions;
        }
        LazyMetadataStorage.load(resolvers);
        TypeMetadataStorage.compile(options.orphanedTypes);
        // includeModules is passed internally from GraphQLSchemaBuilder
        const internalOptions = options;
        this.typeDefinitionsGenerator.generate(options, internalOptions.includeModules);
        const schema = new GraphQLSchema({
            mutation: this.mutationTypeFactory.create(resolvers, options),
            query: this.queryTypeFactory.create(resolvers, options),
            subscription: this.subscriptionTypeFactory.create(resolvers, options),
            types: [
                ...this.orphanedTypesFactory.create(options.orphanedTypes),
                ...(options.scalarsMap ?? []).map(({ scalar }) => scalar),
            ],
            directives: [...specifiedDirectives, ...(options.directives ?? [])],
        });
        if (!options.skipCheck) {
            const introspectionQuery = getIntrospectionQuery();
            const executionResult = await graphql({
                schema,
                source: introspectionQuery,
            });
            const errors = executionResult.errors;
            if (errors) {
                throw new SchemaGenerationError(errors);
            }
        }
        return schema;
    }
    assignScalarObjects(scalars, options) {
        if (isEmpty(scalars)) {
            return;
        }
        const scalarsMap = options.scalarsMap || [];
        scalars
            .filter((classRef) => classRef)
            .forEach((classRef) => this.addScalarTypeByClassRef(classRef, scalarsMap));
        options.scalarsMap = scalarsMap;
    }
    addScalarTypeByClassRef(classRef, scalarsMap) {
        try {
            const scalarNameMetadata = Reflect.getMetadata(SCALAR_NAME_METADATA, classRef);
            const scalarTypeMetadata = Reflect.getMetadata(SCALAR_TYPE_METADATA, classRef);
            if (!scalarNameMetadata) {
                return;
            }
            const instance = new classRef();
            const type = (isFunction(scalarTypeMetadata) && scalarTypeMetadata()) || classRef;
            scalarsMap.push({
                type,
                scalar: createScalarType(scalarNameMetadata, instance),
            });
        }
        catch {
            this.logger.error(`Cannot generate a GraphQLScalarType for "${classRef.name}" scalar. Make sure to put any initialization logic in the lifecycle hooks instead of a constructor.`);
        }
    }
};
GraphQLSchemaFactory = GraphQLSchemaFactory_1 = __decorate([
    Injectable(),
    __metadata("design:paramtypes", [QueryTypeFactory,
        MutationTypeFactory,
        SubscriptionTypeFactory,
        OrphanedTypesFactory,
        TypeDefinitionsGenerator])
], GraphQLSchemaFactory);
export { GraphQLSchemaFactory };