graphql-typescript-definitions/lib/index.js

"use strict";
var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
    return new (P || (P = Promise))(function (resolve, reject) {
        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
        function step(result) { result.done ? resolve(result.value) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); }
        step((generator = generator.apply(thisArg, _arguments || [])).next());
    });
};
var __rest = (this && this.__rest) || function (s, e) {
    var t = {};
    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
        t[p] = s[p];
    if (s != null && typeof Object.getOwnPropertySymbols === "function")
        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) if (e.indexOf(p[i]) < 0)
            t[p[i]] = s[p[i]];
    return t;
};
var __importDefault = (this && this.__importDefault) || function (mod) {
    return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
const events_1 = require("events");
const graphql_1 = require("graphql");
const chalk_1 = __importDefault(require("chalk"));
const path_1 = require("path");
const fs_extra_1 = require("fs-extra");
const chokidar_1 = require("chokidar");
const graphql_config_1 = require("graphql-config");
const graphql_tool_utilities_1 = require("graphql-tool-utilities");
const print_1 = require("./print");
const types_1 = require("./types");
exports.EnumFormat = types_1.EnumFormat;
class Builder extends events_1.EventEmitter {
    constructor(_a) {
        var { cwd } = _a, options = __rest(_a, ["cwd"]);
        super();
        // projectName -> {filePath -> document}
        // NOTE: projectName can be undefined for nameless graphql-config projects
        this.documentMapByProject = new Map();
        this.watchers = [];
        this.options = options;
        this.config = graphql_config_1.getGraphQLConfig(cwd ? path_1.resolve(cwd) : undefined);
    }
    once(event, handler) {
        return super.once(event, handler);
    }
    on(event, handler) {
        return super.on(event, handler);
    }
    emit(event, ...args) {
        return super.emit(event, ...args);
    }
    run({ watch: watchGlobs = false } = {}) {
        return __awaiter(this, void 0, void 0, function* () {
            let schemaPaths;
            try {
                schemaPaths = graphql_tool_utilities_1.getGraphQLSchemaPaths(this.config);
            }
            catch (error) {
                this.emit('error', error);
                return;
            }
            if (watchGlobs) {
                this.watchers.push(...this.setupDocumentWatchers().concat(this.setupSchemaWatcher()));
                // wait for all watchers to be ready
                yield Promise.all(this.watchers.map((watcher) => new Promise((resolve) => watcher.on('ready', () => resolve()))));
            }
            try {
                this.emit('start:schema');
                yield Promise.all(schemaPaths.map((schemaPath) => this.generateSchemaTypes(schemaPath)));
                this.emit('end:schema');
            }
            catch (error) {
                this.emit('error', error);
                return;
            }
            try {
                yield Promise.all(graphql_tool_utilities_1.getGraphQLProjects(this.config).map((projectConfig) => this.updateDocumentsForProject(projectConfig)));
            }
            catch (error) {
                this.emit('error', error);
                return;
            }
            yield this.generateDocumentTypes();
        });
    }
    stop() {
        this.watchers.forEach((watcher) => {
            watcher.close();
        });
        this.watchers.length = 0;
    }
    setupDocumentWatchers() {
        const update = (filePath, projectConfig) => __awaiter(this, void 0, void 0, function* () {
            try {
                yield this.updateDocumentForFile(filePath, projectConfig);
            }
            catch (error) {
                this.emit('error', error);
                return;
            }
            yield this.generateDocumentTypes();
        });
        return graphql_tool_utilities_1.getGraphQLProjects(this.config)
            .filter(({ includes }) => includes.length > 0)
            .map((projectConfig) => {
            return chokidar_1.watch(projectConfig.includes.map((include) => graphql_tool_utilities_1.resolvePathRelativeToConfig(projectConfig, include)), {
                ignored: projectConfig.excludes.map((exclude) => graphql_tool_utilities_1.resolvePathRelativeToConfig(projectConfig, exclude)),
                ignoreInitial: true,
            })
                .on('add', (filePath) => update(filePath, projectConfig))
                .on('change', (filePath) => update(filePath, projectConfig))
                .on('unlink', (filePath) => __awaiter(this, void 0, void 0, function* () {
                const documents = this.documentMapByProject.get(projectConfig.projectName);
                if (documents) {
                    documents.delete(filePath);
                }
                yield this.generateDocumentTypes();
            }));
        });
    }
    setupSchemaWatcher() {
        const update = (schemaPath) => __awaiter(this, void 0, void 0, function* () {
            try {
                this.emit('start:schema');
                yield this.generateSchemaTypes(schemaPath);
                this.emit('end:schema');
                yield this.generateDocumentTypes();
            }
            catch (error) {
                // intentional noop
            }
        });
        return chokidar_1.watch(graphql_tool_utilities_1.getGraphQLSchemaPaths(this.config), { ignoreInitial: true }).on('change', update);
    }
    generateSchemaTypes(schemaPath) {
        return __awaiter(this, void 0, void 0, function* () {
            const projectConfig = graphql_tool_utilities_1.getGraphQLProjectForSchemaPath(this.config, schemaPath);
            const schemaTypesPath = getSchemaTypesPath(projectConfig, this.options);
            const definitions = print_1.generateSchemaTypes(projectConfig.getSchema(), this.options);
            yield fs_extra_1.mkdirp(schemaTypesPath);
            yield Promise.all(Array.from(definitions.entries()).map(([fileName, definition]) => fs_extra_1.writeFile(path_1.join(schemaTypesPath, fileName), definition)));
            this.emit('build:schema', {
                schemaPath,
                schemaTypesPath,
            });
        });
    }
    generateDocumentTypes() {
        return __awaiter(this, void 0, void 0, function* () {
            this.emit('start:docs');
            this.checkForDuplicateOperations();
            yield Promise.all(Array.from(this.documentMapByProject.entries()).map(([projectName, documents]) => this.generateDocumentTypesForProject(this.config.getProjectConfig(projectName), documents)));
            this.emit('end:docs');
        });
    }
    checkForDuplicateOperations() {
        getDuplicateOperations(this.documentMapByProject).forEach(({ projectName, duplicates }) => {
            if (duplicates.length) {
                duplicates.forEach(({ operationName, filePaths }) => {
                    const message = `GraphQL operations must have a unique name. The operation ${chalk_1.default.bold(operationName)} is declared in:\n ${filePaths.sort().join('\n ')}${projectName ? ` (${chalk_1.default.bold(projectName)})` : ''}`;
                    this.emit('error', new Error(message));
                });
            }
        });
    }
    generateDocumentTypesForProject(projectConfig, documents) {
        return __awaiter(this, void 0, void 0, function* () {
            let ast;
            try {
                ast = graphql_tool_utilities_1.compile(projectConfig.getSchema(), graphql_1.concatAST(Array.from(documents.values())));
            }
            catch (error) {
                this.emit('error', error);
                return;
            }
            try {
                yield Promise.all(Array.from(groupOperationsAndFragmentsByFile(ast).values()).map((file) => this.writeDocumentFile(file, ast, projectConfig)));
            }
            catch (error) {
                // intentional noop
            }
        });
    }
    writeDocumentFile(file, ast, projectConfig) {
        return __awaiter(this, void 0, void 0, function* () {
            const definitionPath = `${file.path}.d.ts`;
            yield fs_extra_1.writeFile(definitionPath, this.getDocumentDefinition(file, ast, projectConfig));
            this.emit('build:docs', {
                documentPath: file.path,
                definitionPath,
                operation: file.operation,
                fragments: file.fragments,
            });
        });
    }
    getDocumentDefinition(file, ast, projectConfig) {
        try {
            return print_1.printDocument(file, ast, {
                enumFormat: this.options.enumFormat,
                addTypename: this.options.addTypename,
                schemaTypesPath: getSchemaTypesPath(projectConfig, this.options),
            });
        }
        catch ({ message }) {
            const error = new Error(`Error in ${file.path}: ${message[0].toLowerCase()}${message.slice(1)}`);
            this.emit('error', error);
            throw error;
        }
    }
    updateDocumentsForProject(projectConfig) {
        return __awaiter(this, void 0, void 0, function* () {
            const filePaths = yield graphql_tool_utilities_1.getGraphQLProjectIncludedFilePaths(projectConfig);
            return Promise.all(filePaths.map((filePath) => this.updateDocumentForFile(filePath, projectConfig)));
        });
    }
    updateDocumentForFile(filePath, projectConfig) {
        return __awaiter(this, void 0, void 0, function* () {
            const contents = yield fs_extra_1.readFile(filePath, 'utf8');
            return this.setDocumentForFilePath(filePath, projectConfig, contents);
        });
    }
    setDocumentForFilePath(filePath, projectConfig, contents) {
        let documents = this.documentMapByProject.get(projectConfig.projectName);
        if (!documents) {
            documents = new Map();
            this.documentMapByProject.set(projectConfig.projectName, documents);
        }
        if (contents.trim().length === 0) {
            return undefined;
        }
        const document = graphql_1.parse(new graphql_1.Source(contents, filePath));
        documents.set(filePath, document);
        return document;
    }
}
exports.Builder = Builder;
function getSchemaTypesPath(projectConfig, options) {
    if (typeof projectConfig.extensions.schemaTypesPath === 'string') {
        return graphql_tool_utilities_1.resolvePathRelativeToConfig(projectConfig, projectConfig.extensions.schemaTypesPath);
    }
    return graphql_tool_utilities_1.resolvePathRelativeToConfig(projectConfig, path_1.join(options.schemaTypesPath, `${projectConfig.projectName ? `${projectConfig.projectName}-` : ''}types`));
}
function groupOperationsAndFragmentsByFile({ operations, fragments }) {
    return Object.values(operations)
        .concat(Object.values(fragments))
        .reduce((map, item) => {
        if (!item.filePath) {
            return map;
        }
        let file = map.get(item.filePath);
        if (!file) {
            file = {
                path: item.filePath,
                operation: undefined,
                fragments: [],
            };
            map.set(item.filePath, file);
        }
        if (graphql_tool_utilities_1.isOperation(item)) {
            file.operation = item;
        }
        else {
            file.fragments.push(item);
        }
        return map;
    }, new Map());
}
function getDuplicateOperations(documentsMapByProject) {
    return Array.from(documentsMapByProject.entries()).map(([projectName, documents]) => {
        return {
            projectName,
            duplicates: getDuplicateProjectOperations(documents),
        };
    });
}
function getDuplicateProjectOperations(documents) {
    const operations = new Map();
    Array.from(documents.entries()).forEach(([filePath, document]) => {
        document.definitions.filter(isOperationDefinition).forEach((definition) => {
            const { name } = definition;
            if (name && name.value) {
                const map = operations.get(name.value);
                if (map) {
                    map.add(filePath);
                }
                else {
                    operations.set(name.value, new Set([filePath]));
                }
            }
        });
    });
    return Array.from(operations.entries())
        .filter(([, filePaths]) => filePaths.size > 1)
        .map(([operationName, filePath]) => {
        return { operationName, filePaths: Array.from(filePath) };
    });
}
function isOperationDefinition(definition) {
    return definition.kind === 'OperationDefinition';
}