apollo/lib/generate.js

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const localfs_1 = require("apollo-codegen-core/lib/localfs");
const path = require("path");
const loading_1 = require("apollo-codegen-core/lib/loading");
const validation_1 = require("./validation");
const compiler_1 = require("apollo-codegen-core/lib/compiler");
const legacyIR_1 = require("apollo-codegen-core/lib/compiler/legacyIR");
const serializeToJSON_1 = require("apollo-codegen-core/lib/serializeToJSON");
const apollo_codegen_swift_1 = require("apollo-codegen-swift");
const apollo_codegen_typescript_legacy_1 = require("apollo-codegen-typescript-legacy");
const apollo_codegen_flow_legacy_1 = require("apollo-codegen-flow-legacy");
const apollo_codegen_flow_1 = require("apollo-codegen-flow");
const apollo_codegen_typescript_1 = require("apollo-codegen-typescript");
const apollo_codegen_scala_1 = require("apollo-codegen-scala");
function generate(inputPaths, schema, outputPath, only, target, tagName, nextToSources, options) {
    let writtenFiles = 0;
    const document = loading_1.loadAndMergeQueryDocuments(inputPaths, tagName);
    validation_1.validateQueryDocument(schema, document);
    if (outputPath.split(".").length <= 1 && !localfs_1.fs.existsSync(outputPath)) {
        localfs_1.fs.mkdirSync(outputPath);
    }
    if (target === "swift") {
        options.addTypename = true;
        const context = compiler_1.compileToIR(schema, document, options);
        const outputIndividualFiles = localfs_1.fs.existsSync(outputPath) && localfs_1.fs.statSync(outputPath).isDirectory();
        const generator = apollo_codegen_swift_1.generateSource(context, outputIndividualFiles, only);
        if (outputIndividualFiles) {
            writeGeneratedFiles(generator.generatedFiles, outputPath);
            writtenFiles += Object.keys(generator.generatedFiles).length;
        }
        else {
            localfs_1.fs.writeFileSync(outputPath, generator.output);
            writtenFiles += 1;
        }
        if (options.generateOperationIds) {
            writeOperationIdsMap(context);
            writtenFiles += 1;
        }
    }
    else if (target === "flow") {
        const context = compiler_1.compileToIR(schema, document, options);
        const { generatedFiles, common } = apollo_codegen_flow_1.generateSource(context);
        const outFiles = {};
        if (nextToSources) {
            generatedFiles.forEach(({ sourcePath, fileName, content }) => {
                const dir = path.join(path.dirname(sourcePath), outputPath);
                if (!localfs_1.fs.existsSync(dir)) {
                    localfs_1.fs.mkdirSync(dir);
                }
                outFiles[path.join(dir, fileName)] = {
                    output: content.fileContents + common
                };
            });
            writeGeneratedFiles(outFiles, path.resolve("."));
            writtenFiles += Object.keys(outFiles).length;
        }
        else if (localfs_1.fs.existsSync(outputPath) &&
            localfs_1.fs.statSync(outputPath).isDirectory()) {
            generatedFiles.forEach(({ fileName, content }) => {
                outFiles[fileName] = {
                    output: content.fileContents + common
                };
            });
            writeGeneratedFiles(outFiles, outputPath);
            writtenFiles += Object.keys(outFiles).length;
        }
        else {
            localfs_1.fs.writeFileSync(outputPath, generatedFiles.map(o => o.content.fileContents).join("\n") + common);
            writtenFiles += 1;
        }
    }
    else if (target === "typescript" || target === "ts") {
        const context = compiler_1.compileToIR(schema, document, options);
        const generatedFiles = apollo_codegen_typescript_1.generateLocalSource(context);
        const generatedGlobalFile = apollo_codegen_typescript_1.generateGlobalSource(context);
        const outFiles = {};
        if (nextToSources ||
            (localfs_1.fs.existsSync(outputPath) && localfs_1.fs.statSync(outputPath).isDirectory())) {
            if (options.globalTypesFile) {
                const globalTypesDir = path.dirname(options.globalTypesFile);
                if (!localfs_1.fs.existsSync(globalTypesDir)) {
                    localfs_1.fs.mkdirSync(globalTypesDir);
                }
            }
            else if (nextToSources && !localfs_1.fs.existsSync(outputPath)) {
                localfs_1.fs.mkdirSync(outputPath);
            }
            const globalSourcePath = options.globalTypesFile || path.join(outputPath, "globalTypes.ts");
            outFiles[globalSourcePath] = {
                output: generatedGlobalFile.fileContents
            };
            generatedFiles.forEach(({ sourcePath, fileName, content }) => {
                let dir = outputPath;
                if (nextToSources) {
                    dir = path.join(path.dirname(sourcePath), dir);
                    if (!localfs_1.fs.existsSync(dir)) {
                        localfs_1.fs.mkdirSync(dir);
                    }
                }
                const outFilePath = path.join(dir, fileName);
                outFiles[outFilePath] = {
                    output: content({ outputPath: outFilePath, globalSourcePath })
                        .fileContents
                };
            });
            writeGeneratedFiles(outFiles, path.resolve("."));
            writtenFiles += Object.keys(outFiles).length;
        }
        else {
            localfs_1.fs.writeFileSync(outputPath, generatedFiles.map(o => o.content().fileContents).join("\n") +
                "\n" +
                generatedGlobalFile.fileContents);
            writtenFiles += 1;
        }
    }
    else {
        let output;
        const context = legacyIR_1.compileToLegacyIR(schema, document, options);
        switch (target) {
            case "json":
                output = serializeToJSON_1.default(context);
                break;
            case "ts-legacy":
            case "typescript-legacy":
                output = apollo_codegen_typescript_legacy_1.generateSource(context);
                break;
            case "flow-legacy":
                output = apollo_codegen_flow_legacy_1.generateSource(context);
                break;
            case "scala":
                output = apollo_codegen_scala_1.generateSource(context);
        }
        if (outputPath) {
            localfs_1.fs.writeFileSync(outputPath, output);
            writtenFiles += 1;
        }
        else {
            console.log(output);
        }
    }
    return writtenFiles;
}
exports.default = generate;
function writeGeneratedFiles(generatedFiles, outputDirectory) {
    for (const [fileName, generatedFile] of Object.entries(generatedFiles)) {
        localfs_1.fs.writeFileSync(path.join(outputDirectory, fileName), generatedFile.output);
    }
}
function writeOperationIdsMap(context) {
    let operationIdsMap = {};
    Object.keys(context.operations)
        .map(k => context.operations[k])
        .forEach(operation => {
        operationIdsMap[operation.operationId] = {
            name: operation.operationName,
            source: operation.source
        };
    });
    localfs_1.fs.writeFileSync(context.options.operationIdsPath, JSON.stringify(operationIdsMap, null, 2));
}
//# sourceMappingURL=generate.js.map