export default function generate()

in packages/graphql-types-generator/src/generate.ts [21:108]
77 lines of code
15 McCabe index (conditional complexity)

export default function generate(
  inputPaths: string[],
  schemaPath: string,
  outputPath: string,
  only: string,
  target: TargetType,
  tagName: string,
  options: any,
) {
  const schema = loadSchema(schemaPath);

  const document = loadAndMergeQueryDocuments(inputPaths, tagName);

  validateQueryDocument(schema, document);

  if (target === 'swift') {
    options.addTypename = true;
    const context = compileToIR(schema, document, options);
    // Complex object suppport
    if (options.complexObjectSupport === 'auto') {
      options.addS3Wrapper = context.typesUsed.some(typesUsed => hasS3Fields(typesUsed));
    } else if (options.complexObjectSupport === 'yes') {
      options.addS3Wrapper = true;
    } else {
      options.addS3Wrapper = false;
    }
    const outputIndividualFiles = fs.existsSync(outputPath) && fs.statSync(outputPath).isDirectory();

    const generator = generateSwiftSource(context, outputIndividualFiles, only);

    if (outputIndividualFiles) {
      writeGeneratedFiles(generator.generatedFiles, outputPath);
    } else {
      fs.writeFileSync(outputPath, generator.output);
    }
  } else if (target === 'flow-modern') {
    const context = compileToIR(schema, document, options);
    const generatedFiles = generateFlowModernSource(context);

    // Group by output directory
    const filesByOutputDirectory: {
      [outputDirectory: string]: {
        [fileName: string]: BasicGeneratedFile;
      };
    } = {};

    Object.keys(generatedFiles).forEach((filePath: string) => {
      const outputDirectory = path.dirname(filePath);
      if (!filesByOutputDirectory[outputDirectory]) {
        filesByOutputDirectory[outputDirectory] = {
          [path.basename(filePath)]: generatedFiles[filePath],
        };
      } else {
        filesByOutputDirectory[outputDirectory][path.basename(filePath)] = generatedFiles[filePath];
      }
    });

    Object.keys(filesByOutputDirectory).forEach(outputDirectory => {
      writeGeneratedFiles(filesByOutputDirectory[outputDirectory], outputDirectory);
    });
  } else {
    let output;
    const context = compileToLegacyIR(schema, document, options);
    switch (target) {
      case 'json':
        output = serializeToJSON(context);
        break;
      case 'ts':
      case 'typescript':
        output = generateTypescriptSource(context);
        break;
      case 'flow':
        output = generateFlowSource(context);
        break;
      case 'scala':
        output = generateScalaSource(context, options);
        break;
      case 'angular':
        output = generateAngularSource(context);
    }

    if (outputPath) {
      fs.outputFileSync(outputPath, output);
    } else {
      console.log(output);
    }
  }
}