@ardatan/relay-compiler 12.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) Facebook, Inc. and its affiliates.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/bin/RelayCompilerBin.js.flow

@@ -0,0 +1,169 @@
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @flow
+ * @format
+ */
+
+// flowlint ambiguous-object-type:error
+
+'use strict';
+
+const _yargs = require('yargs');
+
+const {main} = require('./RelayCompilerMain');
+
+import type {Config} from './RelayCompilerMain';
+
+let RelayConfig;
+try {
+  // eslint-disable-next-line no-eval
+  RelayConfig = eval('require')('relay-config');
+  // eslint-disable-next-line lint/no-unused-catch-bindings
+} catch (_) {}
+
+const options = {
+  schema: {
+    describe: 'Path to schema.graphql or schema.json',
+    demandOption: true,
+    type: 'string',
+    array: false,
+  },
+  src: {
+    describe: 'Root directory of application code',
+    demandOption: true,
+    type: 'string',
+    array: false,
+  },
+  include: {
+    describe: 'Directories to include under src',
+    type: 'string',
+    array: true,
+    default: ['**'],
+  },
+  exclude: {
+    describe: 'Directories to ignore under src',
+    type: 'string',
+    array: true,
+    default: ['**/node_modules/**', '**/__mocks__/**', '**/__generated__/**'],
+  },
+  extensions: {
+    array: true,
+    describe:
+      'File extensions to compile (defaults to extensions provided by the ' +
+      'language plugin)',
+    type: 'string',
+  },
+  verbose: {
+    describe: 'More verbose logging',
+    type: 'boolean',
+    default: false,
+  },
+  quiet: {
+    describe: 'No output to stdout',
+    type: 'boolean',
+    default: false,
+  },
+  watchman: {
+    describe: 'Use watchman when not in watch mode',
+    type: 'boolean',
+    default: true,
+  },
+  watch: {
+    describe: 'If specified, watches files and regenerates on changes',
+    type: 'boolean',
+    default: false,
+  },
+  validate: {
+    describe:
+      'Looks for pending changes and exits with non-zero code instead of ' +
+      'writing to disk',
+    type: 'boolean',
+    default: false,
+  },
+  persistFunction: {
+    describe:
+      'An async function (or path to a module exporting this function) which will persist the query text and return the id.',
+    demandOption: false,
+    type: 'string',
+    array: false,
+  },
+  persistOutput: {
+    describe:
+      'A path to a .json file where persisted query metadata should be saved. Will use the default implementation (md5 hash) if `persistFunction` is not passed.',
+    demandOption: false,
+    type: 'string',
+    array: false,
+  },
+  repersist: {
+    describe: 'Run the persist function even if the query has not changed.',
+    type: 'boolean',
+    default: false,
+  },
+  noFutureProofEnums: {
+    describe:
+      'This option controls whether or not a catch-all entry is added to enum type definitions ' +
+      'for values that may be added in the future. Enabling this means you will have to update ' +
+      'your application whenever the GraphQL server schema adds new enum values to prevent it ' +
+      'from breaking.',
+    type: 'boolean',
+    default: false,
+  },
+  language: {
+    describe:
+      'The name of the language plugin used for input files and artifacts',
+    demandOption: false,
+    type: 'string',
+    array: false,
+    default: 'javascript',
+  },
+  artifactDirectory: {
+    describe:
+      'A specific directory to output all artifacts to. When enabling this ' +
+      'the babel plugin needs `artifactDirectory` set as well.',
+    demandOption: false,
+    type: 'string',
+    array: false,
+  },
+  customScalars: {
+    describe:
+      'Mappings from custom scalars in your schema to built-in GraphQL ' +
+      'types, for type emission purposes. (Uses yargs dot-notation, e.g. ' +
+      '--customScalars.URL=String)',
+    type: ('object': $FlowFixMe),
+  },
+  eagerESModules: {
+    describe: 'This option enables emitting es modules artifacts.',
+    type: 'boolean',
+    default: false,
+  },
+};
+
+// Parse CLI args
+let yargs = _yargs
+  .usage(
+    'Create Relay generated files\n\n' +
+      '$0 --schema <path> --src <path> [--watch]',
+  )
+  .options(options)
+  .strict();
+
+// Load external config
+const config = RelayConfig && RelayConfig.loadConfig();
+if (config) {
+  // Apply externally loaded config through the yargs API so that we can leverage yargs' defaults and have them show up
+  // in the help banner. We add it conditionally otherwise yargs would add new option `--config` which is confusing for
+  // Relay users (it's not Relay Config file).
+  yargs = yargs.config(config);
+}
+
+const argv: Config = (yargs.help().argv: $FlowFixMe);
+
+// Start the application
+main(argv).catch(error => {
+  console.error(String(error.stack || error));
+  process.exit(1);
+});

package/bin/RelayCompilerMain.js.flow

@@ -0,0 +1,515 @@
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @flow
+ * @format
+ */
+
+// flowlint ambiguous-object-type:error
+
+'use strict';
+
+const CodegenRunner = require('../codegen/CodegenRunner');
+const ConsoleReporter = require('../reporters/ConsoleReporter');
+const DotGraphQLParser = require('../core/DotGraphQLParser');
+const RelayFileWriter = require('../codegen/RelayFileWriter');
+const RelayIRTransforms = require('../core/RelayIRTransforms');
+const RelayLanguagePluginJavaScript = require('../language/javascript/RelayLanguagePluginJavaScript');
+const RelaySourceModuleParser = require('../core/RelaySourceModuleParser');
+const WatchmanClient = require('../core/GraphQLWatchmanClient');
+
+const crypto = require('crypto');
+const fs = require('fs');
+const glob = require('glob');
+const invariant = require('invariant');
+const path = require('path');
+
+const {buildClientSchema, Source, printSchema} = require('graphql');
+
+const {
+  commonTransforms,
+  codegenTransforms,
+  fragmentTransforms,
+  printTransforms,
+  queryTransforms,
+  schemaExtensions: relaySchemaExtensions,
+} = RelayIRTransforms;
+
+import type {ScalarTypeMapping} from '../language/javascript/RelayFlowTypeTransformers';
+import type {WriteFilesOptions} from '../codegen/CodegenRunner';
+import type {
+  PluginInitializer,
+  PluginInterface,
+} from '../language/RelayLanguagePluginInterface';
+
+export type Config = {|
+  schema: string,
+  src: string,
+  extensions: Array<string>,
+  include: Array<string>,
+  exclude: Array<string>,
+  verbose: boolean,
+  watchman: boolean,
+  watch?: ?boolean,
+  validate: boolean,
+  quiet: boolean,
+  persistOutput?: ?string,
+  noFutureProofEnums: boolean,
+  eagerESModules?: boolean,
+  language: string | PluginInitializer,
+  persistFunction?: ?string | ?((text: string) => Promise<string>),
+  repersist: boolean,
+  artifactDirectory?: ?string,
+  customScalars?: ScalarTypeMapping,
+|};
+
+function buildWatchExpression(config: {
+  extensions: Array<string>,
+  include: Array<string>,
+  exclude: Array<string>,
+  ...
+}) {
+  return [
+    'allof',
+    ['type', 'f'],
+    ['anyof', ...config.extensions.map(ext => ['suffix', ext])],
+    [
+      'anyof',
+      ...config.include.map(include => ['match', include, 'wholename']),
+    ],
+    ...config.exclude.map(exclude => ['not', ['match', exclude, 'wholename']]),
+  ];
+}
+
+function getFilepathsFromGlob(
+  baseDir,
+  config: {
+    extensions: Array<string>,
+    include: Array<string>,
+    exclude: Array<string>,
+    ...
+  },
+): Array<string> {
+  const {extensions, include, exclude} = config;
+
+  const files = new Set();
+  include.forEach(inc =>
+    glob
+      .sync(`${inc}/*.+(${extensions.join('|')})`, {
+        cwd: baseDir,
+        ignore: exclude,
+      })
+      .forEach(file => files.add(file)),
+  );
+  return Array.from(files);
+}
+
+type LanguagePlugin = PluginInitializer | {default: PluginInitializer, ...};
+
+/**
+ * Unless the requested plugin is the builtin `javascript` one, import a
+ * language plugin as either a CommonJS or ES2015 module.
+ *
+ * When importing, first check if it’s a path to an existing file, otherwise
+ * assume it’s a package and prepend the plugin namespace prefix.
+ *
+ * Make sure to always use Node's `require` function, which otherwise would get
+ * replaced with `__webpack_require__` when bundled using webpack, by using
+ * `eval` to get it at runtime.
+ */
+function getLanguagePlugin(
+  language: string | PluginInitializer,
+  options?: {|
+    eagerESModules: boolean,
+  |},
+): PluginInterface {
+  if (language === 'javascript') {
+    return RelayLanguagePluginJavaScript({
+      eagerESModules: Boolean(options && options.eagerESModules),
+    });
+  } else {
+    let languagePlugin: LanguagePlugin;
+    if (typeof language === 'string') {
+      const pluginPath = path.resolve(process.cwd(), language);
+      const requirePath = fs.existsSync(pluginPath)
+        ? pluginPath
+        : `relay-compiler-language-${language}`;
+      try {
+        // eslint-disable-next-line no-eval
+        languagePlugin = eval('require')(requirePath);
+        if (languagePlugin.default) {
+          languagePlugin = languagePlugin.default;
+        }
+      } catch (err) {
+        const e = new Error(
+          `Unable to load language plugin ${requirePath}: ${err.message}`,
+        );
+        e.stack = err.stack;
+        throw e;
+      }
+    } else {
+      languagePlugin = language;
+    }
+    if (languagePlugin.default != null) {
+      /* $FlowFixMe[incompatible-type] - Flow no longer considers statics of
+       * functions as any */
+      languagePlugin = languagePlugin.default;
+    }
+    if (typeof languagePlugin === 'function') {
+      // $FlowFixMe[incompatible-use]
+      return languagePlugin();
+    } else {
+      throw new Error('Expected plugin to be a initializer function.');
+    }
+  }
+}
+
+function getPersistQueryFunction(
+  config: Config,
+): ?(text: string) => Promise<string> {
+  const configValue = config.persistFunction;
+  if (configValue == null) {
+    return null;
+  } else if (typeof configValue === 'string') {
+    try {
+      // eslint-disable-next-line no-eval
+      const persistFunction = eval('require')(
+        path.resolve(process.cwd(), configValue),
+      );
+      if (persistFunction.default) {
+        return persistFunction.default;
+      }
+      return persistFunction;
+    } catch (err) {
+      const e = new Error(
+        `Unable to load persistFunction ${configValue}: ${err.message}`,
+      );
+      e.stack = err.stack;
+      throw e;
+    }
+  } else if (typeof configValue === 'function') {
+    return configValue;
+  } else {
+    throw new Error(
+      'Expected persistFunction to be a path string or a function.',
+    );
+  }
+}
+
+async function main(defaultConfig: Config) {
+  if (defaultConfig.verbose && defaultConfig.quiet) {
+    throw new Error("I can't be quiet and verbose at the same time");
+  }
+
+  let config = getPathBasedConfig(defaultConfig);
+  config = await getWatchConfig(config);
+
+  // Use function from module.exports to be able to mock it for tests
+  const codegenRunner = module.exports.getCodegenRunner(config);
+
+  const result = config.watch
+    ? await codegenRunner.watchAll()
+    : await codegenRunner.compileAll();
+
+  if (result === 'ERROR') {
+    process.exit(100);
+  }
+  if (config.validate && result !== 'NO_CHANGES') {
+    process.exit(101);
+  }
+}
+
+function getPathBasedConfig(config: Config) {
+  const schema = path.resolve(process.cwd(), config.schema);
+  if (!fs.existsSync(schema)) {
+    throw new Error(`--schema path does not exist: ${schema}`);
+  }
+
+  const src = path.resolve(process.cwd(), config.src);
+  if (!fs.existsSync(src)) {
+    throw new Error(`--src path does not exist: ${src}`);
+  }
+
+  let persistOutput = config.persistOutput;
+  if (typeof persistOutput === 'string') {
+    persistOutput = path.resolve(process.cwd(), persistOutput);
+    const persistOutputDir = path.dirname(persistOutput);
+    if (!fs.existsSync(persistOutputDir)) {
+      throw new Error(`--persistOutput path does not exist: ${persistOutput}`);
+    }
+  }
+
+  return {...config, schema, src, persistOutput};
+}
+
+async function getWatchConfig(config: Config): Promise<Config> {
+  const watchman = config.watchman && (await WatchmanClient.isAvailable());
+
+  if (config.watch) {
+    if (!watchman) {
+      console.error(
+        'Watchman is required to watch for changes. Running with watch mode disabled.',
+      );
+      return {...config, watch: false, watchman: false};
+    }
+    if (!module.exports.hasWatchmanRootFile(config.src)) {
+      throw new Error(
+        `
+--watch requires that the src directory have a valid watchman "root" file.
+
+Root files can include:
+- A .git/ Git folder
+- A .hg/ Mercurial folder
+- A .watchmanconfig file
+
+Ensure that one such file exists in ${config.src} or its parents.
+      `.trim(),
+      );
+    }
+  } else if (watchman && !config.validate) {
+    // eslint-disable-next-line no-console
+    console.log('HINT: pass --watch to keep watching for changes.');
+  }
+
+  return {...config, watchman};
+}
+
+function getCodegenRunner(config: Config): CodegenRunner {
+  const reporter = new ConsoleReporter({
+    verbose: config.verbose,
+    quiet: config.quiet,
+  });
+  const schema = getSchemaSource(config.schema);
+  const languagePlugin = getLanguagePlugin(config.language, {
+    eagerESModules: config.eagerESModules === true,
+  });
+  const persistQueryFunction = getPersistQueryFunction(config);
+  const inputExtensions = config.extensions || languagePlugin.inputExtensions;
+  const outputExtension = languagePlugin.outputExtension;
+  const sourceParserName = inputExtensions.join('/');
+  const sourceWriterName = outputExtension;
+  const sourceModuleParser = RelaySourceModuleParser(
+    languagePlugin.findGraphQLTags,
+    languagePlugin.getFileFilter,
+  );
+  const providedArtifactDirectory = config.artifactDirectory;
+  const artifactDirectory =
+    providedArtifactDirectory != null
+      ? path.resolve(process.cwd(), providedArtifactDirectory)
+      : null;
+  const generatedDirectoryName = artifactDirectory ?? '__generated__';
+  const sourceSearchOptions = {
+    extensions: inputExtensions,
+    include: config.include,
+    exclude: ['**/*.graphql.*', ...config.exclude],
+  };
+  const graphqlSearchOptions = {
+    extensions: ['graphql'],
+    include: config.include,
+    exclude: [path.relative(config.src, config.schema)].concat(config.exclude),
+  };
+  const defaultIsGeneratedFile = (filePath: string) =>
+    filePath.endsWith('.graphql.' + outputExtension) &&
+    filePath.includes(generatedDirectoryName);
+  const schemaExtensions = languagePlugin.schemaExtensions
+    ? [...languagePlugin.schemaExtensions, ...relaySchemaExtensions]
+    : relaySchemaExtensions;
+  const parserConfigs = {
+    [sourceParserName]: {
+      baseDir: config.src,
+      getFileFilter: sourceModuleParser.getFileFilter,
+      getParser: sourceModuleParser.getParser,
+      getSchemaSource: () => schema,
+      schemaExtensions,
+      watchmanExpression: config.watchman
+        ? buildWatchExpression(sourceSearchOptions)
+        : null,
+      filepaths: config.watchman
+        ? null
+        : getFilepathsFromGlob(config.src, sourceSearchOptions),
+    },
+    graphql: {
+      baseDir: config.src,
+      getParser: DotGraphQLParser.getParser,
+      getSchemaSource: () => schema,
+      schemaExtensions,
+      watchmanExpression: config.watchman
+        ? buildWatchExpression(graphqlSearchOptions)
+        : null,
+      filepaths: config.watchman
+        ? null
+        : getFilepathsFromGlob(config.src, graphqlSearchOptions),
+    },
+  };
+  const writerConfigs = {
+    [sourceWriterName]: {
+      writeFiles: getRelayFileWriter(
+        config.src,
+        languagePlugin,
+        config.noFutureProofEnums,
+        artifactDirectory,
+        config.persistOutput,
+        config.customScalars,
+        persistQueryFunction,
+        config.repersist,
+      ),
+      isGeneratedFile: languagePlugin.isGeneratedFile
+        ? languagePlugin.isGeneratedFile
+        : defaultIsGeneratedFile,
+      parser: sourceParserName,
+      baseParsers: ['graphql'],
+    },
+  };
+  const codegenRunner = new CodegenRunner({
+    reporter,
+    parserConfigs,
+    writerConfigs,
+    onlyValidate: config.validate,
+    // TODO: allow passing in a flag or detect?
+    sourceControl: null,
+  });
+  return codegenRunner;
+}
+
+function defaultPersistFunction(text: string): Promise<string> {
+  const hasher = crypto.createHash('md5');
+  hasher.update(text);
+  const id = hasher.digest('hex');
+  return Promise.resolve(id);
+}
+
+function getRelayFileWriter(
+  baseDir: string,
+  languagePlugin: PluginInterface,
+  noFutureProofEnums: boolean,
+  outputDir?: ?string,
+  persistedQueryPath?: ?string,
+  customScalars?: ScalarTypeMapping,
+  persistFunction?: ?(text: string) => Promise<string>,
+  repersist?: boolean,
+) {
+  return async ({
+    onlyValidate,
+    schema,
+    documents,
+    baseDocuments,
+    sourceControl,
+    reporter,
+  }: WriteFilesOptions) => {
+    let persistQuery;
+    let queryMap;
+    if (persistFunction != null || persistedQueryPath != null) {
+      queryMap = new Map();
+      const persistImplmentation = persistFunction || defaultPersistFunction;
+      persistQuery = async (text: string) => {
+        const id = await persistImplmentation(text);
+        invariant(
+          typeof id === 'string',
+          'Expected persist function to return a string, got `%s`.',
+          id,
+        );
+        queryMap.set(id, text);
+        return id;
+      };
+    }
+    const schemaExtensions = languagePlugin.schemaExtensions
+      ? [...languagePlugin.schemaExtensions, ...relaySchemaExtensions]
+      : relaySchemaExtensions;
+    const results = await RelayFileWriter.writeAll({
+      config: {
+        baseDir,
+        compilerTransforms: {
+          commonTransforms,
+          codegenTransforms,
+          fragmentTransforms,
+          printTransforms,
+          queryTransforms,
+        },
+        customScalars: customScalars || {},
+        formatModule: languagePlugin.formatModule,
+        optionalInputFieldsForFlow: [],
+        schemaExtensions,
+        useHaste: false,
+        noFutureProofEnums,
+        extension: languagePlugin.outputExtension,
+        typeGenerator: languagePlugin.typeGenerator,
+        outputDir,
+        persistQuery,
+        repersist,
+      },
+      onlyValidate,
+      schema,
+      baseDocuments,
+      documents,
+      reporter,
+      sourceControl,
+      languagePlugin,
+    });
+    if (queryMap != null && persistedQueryPath != null) {
+      let object = {};
+      if (fs.existsSync(persistedQueryPath)) {
+        try {
+          const prevText = fs.readFileSync(persistedQueryPath, 'utf8');
+          const prevData = JSON.parse(prevText);
+          if (prevData != null && typeof prevData === 'object') {
+            object = prevData;
+          } else {
+            console.error(
+              `Invalid data in persisted query file '${persistedQueryPath}', expected an object.`,
+            );
+          }
+        } catch (error) {
+          console.error(error);
+        }
+      }
+      for (const [id, text] of queryMap.entries()) {
+        object[id] = text;
+      }
+      const data = JSON.stringify(object, null, 2);
+      fs.writeFileSync(persistedQueryPath, data, 'utf8');
+    }
+    return results;
+  };
+}
+
+function getSchemaSource(schemaPath: string): Source {
+  let source = fs.readFileSync(schemaPath, 'utf8');
+  if (path.extname(schemaPath) === '.json') {
+    source = printSchema(buildClientSchema(JSON.parse(source).data));
+  }
+  source = `
+  directive @include(if: Boolean) on FRAGMENT_SPREAD | FIELD | INLINE_FRAGMENT
+  directive @skip(if: Boolean) on FRAGMENT_SPREAD | FIELD | INLINE_FRAGMENT
+
+  ${source}
+  `;
+  return new Source(source, schemaPath);
+}
+
+// Ensure that a watchman "root" file exists in the given directory
+// or a parent so that it can be watched
+const WATCHMAN_ROOT_FILES = ['.git', '.hg', '.watchmanconfig'];
+function hasWatchmanRootFile(testPath: string): boolean {
+  while (path.dirname(testPath) !== testPath) {
+    if (
+      WATCHMAN_ROOT_FILES.some(file => {
+        return fs.existsSync(path.join(testPath, file));
+      })
+    ) {
+      return true;
+    }
+    testPath = path.dirname(testPath);
+  }
+  return false;
+}
+
+module.exports = {
+  getCodegenRunner,
+  getLanguagePlugin,
+  getWatchConfig,
+  hasWatchmanRootFile,
+  main,
+};