relay-compiler 7.0.0 → 9.1.0

package/language/RelayLanguagePluginInterface.js.flow

@@ -0,0 +1,283 @@
+/**
+ * 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 strict-local
+ * @format
+ */
+
+// flowlint ambiguous-object-type:error
+
+'use strict';
+
+const {RelayConcreteNode} = require('relay-runtime');
+
+import type {
+  IsGeneratedFileFn,
+  KeepExtraFileFn,
+} from '../codegen/CodegenRunner';
+import type {IRTransform} from '../core/CompilerContext';
+import type {GeneratedDefinition, Root, Fragment} from '../core/IR';
+import type {GetFileFilter} from '../core/RelaySourceModuleParser';
+import type {Schema} from '../core/Schema';
+import type {ScalarTypeMapping} from './javascript/RelayFlowTypeTransformers';
+import type {GeneratedNode} from 'relay-runtime';
+
+/**
+ * A language plugin allows relay-compiler to both read and write files for any
+ * language.
+ *
+ * When reading, the plugin is expected to parse and return GraphQL tags; and
+ * when writing the plugin is responsible for generating type information about
+ * the GraphQL selections made as well as generating the contents of the
+ * artifact file.
+ *
+ * This interface describes the details relay-compiler requires to be able to
+ * use the plugin and is expected to be returned by a {PluginInitializer}.
+ */
+export type PluginInterface = {
+  inputExtensions: string[],
+  outputExtension: string,
+  findGraphQLTags: GraphQLTagFinder,
+  formatModule: FormatModule,
+  typeGenerator: TypeGenerator,
+  isGeneratedFile?: IsGeneratedFileFn,
+  keepExtraFile?: KeepExtraFileFn,
+  schemaExtensions?: $ReadOnlyArray<string>,
+  getModuleName?: (operationName: string) => string,
+  getFileFilter?: GetFileFilter,
+  ...
+};
+
+/**
+ * The plugin is expected to have as its main default export a function that
+ * returns an object conforming to the plugin interface.
+ *
+ * For now a plugin doesn’t take any arguments, but may do so in the future.
+ */
+export type PluginInitializer = () => PluginInterface;
+
+export type GraphQLTag = {
+  /**
+   * Should hold the string content of the `graphql` tagged template literal,
+   * which is either an operation or fragment.
+   *
+   * @example
+   *
+   *  grapqhl`query MyQuery { … }`
+   *  grapqhl`fragment MyFragment on MyType { … }`
+   */
+  template: string,
+  /**
+   * In the case this tag was part of a fragment container and it used a node
+   * map as fragment spec, rather than a single tagged node, this should hold
+   * the prop key to which the node is assigned.
+   *
+   * @example
+   *
+   *  createFragmentContainer(
+   *    MyComponent,
+   *    {
+   *      keyName: graphql`fragment MyComponent_keyName { … }`
+   *    }
+   *  )
+   *
+   */
+  keyName: ?string,
+  /**
+   * The location in the source file that the tag is placed at.
+   */
+  sourceLocationOffset: {|
+    /**
+     * The line in the source file that the tag is placed on.
+     *
+     * Lines use 1-based indexing.
+     */
+    line: number,
+
+    /**
+     * The column in the source file that the tag starts on.
+     *
+     * Columns use 1-based indexing.
+     */
+    column: number,
+  |},
+  ...
+};
+
+/**
+ * This function is responsible for extracting `GraphQLTag` objects from source
+ * files.
+ *
+ * @param  {string} text       The source file contents.
+ * @param  {string} filePath   The path to the source file on disk.
+ * @return {Array<GraphQLTag>} All extracted `GraphQLTag` objects.
+ *
+ * @see {@link javascript/FindGraphQLTags.js}
+ */
+export type GraphQLTagFinder = (
+  text: string,
+  filePath: string,
+) => $ReadOnlyArray<GraphQLTag>;
+
+/**
+ * The function that is responsible for generating the contents of the artifact
+ * file.
+ *
+ * @see {@link javascript/formatGeneratedModule.js}
+ */
+export type FormatModule = ({|
+  /**
+   * The filename of the module.
+   */
+  moduleName: string,
+
+  /**
+   * The type of artifact that this module represents.
+   *
+   * @todo Document when this can be `empty`.
+   */
+  documentType:
+    | typeof RelayConcreteNode.FRAGMENT
+    | typeof RelayConcreteNode.REQUEST
+    | null,
+
+  /**
+   * The actual document that this module represents.
+   */
+  docText: ?string,
+
+  /**
+   * The IR for the document that this module represents.
+   */
+  concreteText: string,
+
+  /**
+   * The type information generated for the GraphQL selections made.
+   */
+  typeText: string,
+
+  /**
+   * A hash of the concrete node including the query text.
+   *
+   * @todo Document how this is different from `sourceHash`.
+   */
+  hash: ?string,
+
+  /**
+   * The 'kind' of the generated node.
+   */
+  kind: string,
+
+  /**
+   * The IR node from which the generated node is derived.
+   */
+  definition: GeneratedDefinition,
+
+  /**
+   * A hash of the document, which is used by relay-compiler to know if it needs
+   * to write a new version of the artifact.
+   *
+   * @todo Is this correct? And document how this is different from `hash`.
+   */
+  sourceHash: string,
+
+  /**
+   * The generated node being written.
+   */
+  node: GeneratedNode,
+
+  /**
+   * GraphQL Schema Interface
+   */
+  schema: Schema,
+|}) => string;
+
+/**
+ * The options that will be passed to the `generate` function of your plugin’s
+ * type generator.
+ */
+export type TypeGeneratorOptions = {|
+  /**
+   * A map of custom scalars to scalars that the plugin knows about and emits
+   * type information for.
+   *
+   * @example
+   *
+   *  // The URL custom scalar is essentially a string and should be treated as
+   *  // such by the language’s type system.
+   *  { URL: 'String' }
+   */
+  +customScalars: ScalarTypeMapping,
+
+  /**
+   * Whether or not relay-compiler will store artifacts next to the module that
+   * they originate from or all together in a single directory.
+   *
+   * Storing all artifacts in a single directory makes it easy to import and
+   * reference fragments defined in other artifacts without needing to use the
+   * Haste module system.
+   *
+   * This defaults to `false`.
+   */
+  +useSingleArtifactDirectory: boolean,
+
+  /**
+   * 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.
+   *
+   * This defaults to `false`.
+   */
+  +noFutureProofEnums: boolean,
+
+  /**
+   * @todo Document this.
+   */
+  +optionalInputFields: $ReadOnlyArray<string>,
+
+  /**
+   * Whether or not the Haste module system is being used. This will currently
+   * always be `false` for OSS users.
+   */
+  +useHaste: boolean,
+
+  /**
+   * Import flow types from the Haste-style global module name or per-enum
+   * global module name given by the function variant.
+   */
+  +enumsHasteModule?: string | ((enumName: string) => string),
+
+  /**
+   * Optional normalization IR for generating raw response
+   */
+  +normalizationIR?: Root,
+|};
+
+/**
+ * This object should hold the implementation required to generate types for the
+ * GraphQL selections made.
+ *
+ * @see {@link javascript/RelayFlowGenerator.js}
+ */
+export type TypeGenerator = {
+  /**
+   * Transforms that should be applied to the intermediate representation of the
+   * GraphQL document before passing to the `generate` function.
+   */
+  transforms: $ReadOnlyArray<IRTransform>,
+  /**
+   * Given GraphQL document IR, this function should generate type information
+   * for e.g. the selections made. It can, however, also generate any other
+   * content such as importing other files, including other artifacts.
+   */
+  generate: (
+    schema: Schema,
+    node: Root | Fragment,
+    options: TypeGeneratorOptions,
+  ) => string,
+  ...
+};

package/language/javascript/FindGraphQLTags.js.flow

@@ -0,0 +1,233 @@
+/**
+ * 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 Profiler = require('../../core/GraphQLCompilerProfiler');
+
+const babylon = require('@babel/parser');
+const util = require('util');
+
+import type {GraphQLTag} from '../RelayLanguagePluginInterface';
+
+// Attempt to be as inclusive as possible of source text.
+const BABYLON_OPTIONS = {
+  allowImportExportEverywhere: true,
+  allowReturnOutsideFunction: true,
+  allowSuperOutsideMethod: true,
+  sourceType: 'module',
+  plugins: [
+    // Previously "*"
+    'asyncGenerators',
+    'classProperties',
+    ['decorators', {decoratorsBeforeExport: true}],
+    'doExpressions',
+    'dynamicImport',
+    'exportExtensions',
+    'flow',
+    'functionBind',
+    'functionSent',
+    'jsx',
+    'nullishCoalescingOperator',
+    'objectRestSpread',
+    'optionalChaining',
+    'optionalCatchBinding',
+  ],
+  strictMode: false,
+};
+
+function find(text: string): $ReadOnlyArray<GraphQLTag> {
+  const result: Array<GraphQLTag> = [];
+  const ast = babylon.parse(text, BABYLON_OPTIONS);
+
+  const visitors = {
+    CallExpression: node => {
+      const callee = node.callee;
+      if (
+        !(
+          (callee.type === 'Identifier' &&
+            CREATE_CONTAINER_FUNCTIONS[callee.name]) ||
+          (callee.kind === 'MemberExpression' &&
+            callee.object.type === 'Identifier' &&
+            callee.object.value === 'Relay' &&
+            callee.property.type === 'Identifier' &&
+            CREATE_CONTAINER_FUNCTIONS[callee.property.name])
+        )
+      ) {
+        traverse(node, visitors);
+        return;
+      }
+      const fragments = node.arguments[1];
+      if (fragments.type === 'ObjectExpression') {
+        fragments.properties.forEach(property => {
+          invariant(
+            property.type === 'ObjectProperty' &&
+              property.key.type === 'Identifier' &&
+              property.value.type === 'TaggedTemplateExpression',
+            'FindGraphQLTags: `%s` expects fragment definitions to be ' +
+              '`key: graphql`.',
+            node.callee.name,
+          );
+          invariant(
+            isGraphQLModernOrDeprecatedTag(property.value.tag),
+            'FindGraphQLTags: `%s` expects fragment definitions to be tagged ' +
+              'with `graphql`, got `%s`.',
+            node.callee.name,
+            getSourceTextForLocation(text, property.value.tag.loc),
+          );
+          if (isGraphQLTag(property.value.tag)) {
+            result.push({
+              keyName: property.key.name,
+              template: getGraphQLText(property.value.quasi),
+              sourceLocationOffset: getSourceLocationOffset(
+                property.value.quasi,
+              ),
+            });
+          }
+        });
+      } else {
+        invariant(
+          fragments && fragments.type === 'TaggedTemplateExpression',
+          'FindGraphQLTags: `%s` expects a second argument of fragment ' +
+            'definitions.',
+          node.callee.name,
+        );
+        invariant(
+          isGraphQLModernOrDeprecatedTag(fragments.tag),
+          'FindGraphQLTags: `%s` expects fragment definitions to be tagged ' +
+            'with `graphql`, got `%s`.',
+          node.callee.name,
+          getSourceTextForLocation(text, fragments.tag.loc),
+        );
+        result.push({
+          keyName: null,
+          template: getGraphQLText(fragments.quasi),
+          sourceLocationOffset: getSourceLocationOffset(fragments.quasi),
+        });
+      }
+
+      // Visit remaining arguments
+      for (let ii = 2; ii < node.arguments.length; ii++) {
+        visit(node.arguments[ii], visitors);
+      }
+    },
+    TaggedTemplateExpression: node => {
+      if (isGraphQLTag(node.tag)) {
+        result.push({
+          keyName: null,
+          template: node.quasi.quasis[0].value.raw,
+          sourceLocationOffset: getSourceLocationOffset(node.quasi),
+        });
+      }
+    },
+  };
+  visit(ast, visitors);
+  return result;
+}
+
+const CREATE_CONTAINER_FUNCTIONS = Object.create(null, {
+  createFragmentContainer: {value: true},
+  createPaginationContainer: {value: true},
+  createRefetchContainer: {value: true},
+});
+
+const IGNORED_KEYS = {
+  comments: true,
+  end: true,
+  leadingComments: true,
+  loc: true,
+  name: true,
+  start: true,
+  trailingComments: true,
+  type: true,
+};
+
+function isGraphQLTag(tag): boolean {
+  return tag.type === 'Identifier' && tag.name === 'graphql';
+}
+
+function isGraphQLModernOrDeprecatedTag(tag): boolean {
+  return (
+    tag.type === 'Identifier' &&
+    (tag.name === 'graphql' || tag.name === 'graphql_DEPRECATED')
+  );
+}
+
+function getTemplateNode(quasi) {
+  const quasis = quasi.quasis;
+  invariant(
+    quasis && quasis.length === 1,
+    'FindGraphQLTags: Substitutions are not allowed in graphql tags.',
+  );
+  return quasis[0];
+}
+
+function getGraphQLText(quasi): string {
+  return getTemplateNode(quasi).value.raw;
+}
+
+function getSourceLocationOffset(quasi) {
+  const loc = getTemplateNode(quasi).loc.start;
+  return {
+    line: loc.line,
+    column: loc.column + 1, // babylon is 0-indexed, graphql expects 1-indexed
+  };
+}
+
+function getSourceTextForLocation(text, loc) {
+  if (loc == null) {
+    return '(source unavailable)';
+  }
+  const lines = text.split('\n').slice(loc.start.line - 1, loc.end.line);
+  lines[0] = lines[0].slice(loc.start.column);
+  lines[lines.length - 1] = lines[lines.length - 1].slice(0, loc.end.column);
+  return lines.join('\n');
+}
+
+function invariant(condition, msg, ...args) {
+  if (!condition) {
+    throw new Error(util.format(msg, ...args));
+  }
+}
+
+function visit(node, visitors) {
+  const fn = visitors[node.type];
+  if (fn != null) {
+    fn(node);
+    return;
+  }
+  traverse(node, visitors);
+}
+
+function traverse(node, visitors) {
+  for (const key in node) {
+    if (IGNORED_KEYS[key]) {
+      continue;
+    }
+    const prop = node[key];
+    if (prop && typeof prop === 'object' && typeof prop.type === 'string') {
+      visit(prop, visitors);
+    } else if (Array.isArray(prop)) {
+      prop.forEach(item => {
+        if (item && typeof item === 'object' && typeof item.type === 'string') {
+          visit(item, visitors);
+        }
+      });
+    }
+  }
+}
+
+module.exports = {
+  find: (Profiler.instrument(find, 'FindGraphQLTags.find'): (
+    text: string,
+  ) => $ReadOnlyArray<GraphQLTag>),
+};

package/language/javascript/RelayFlowBabelFactories.js.flow

@@ -0,0 +1,180 @@
+/**
+ * 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 strict
+ * @format
+ */
+
+// flowlint ambiguous-object-type:error
+
+'use strict';
+
+const invariant = require('invariant');
+const t = require('@babel/types');
+
+type BabelAST = mixed;
+
+/**
+ * type NAME = any;
+ */
+function anyTypeAlias(name: string): BabelAST {
+  return t.typeAlias(t.identifier(name), null, t.anyTypeAnnotation());
+}
+
+/**
+ * {|
+ *   PROPS
+ * |}
+ */
+function exactObjectTypeAnnotation(
+  props: $ReadOnlyArray<BabelAST>,
+): $FlowFixMe {
+  const typeAnnotation = t.objectTypeAnnotation(props);
+  typeAnnotation.exact = true;
+  return typeAnnotation;
+}
+
+/**
+ * {
+ *   PROPS
+ *   ...
+ * }
+ */
+function inexactObjectTypeAnnotation(
+  props: $ReadOnlyArray<BabelAST>,
+): $FlowFixMe {
+  const typeAnnotation = t.objectTypeAnnotation(props);
+  typeAnnotation.inexact = true;
+  return typeAnnotation;
+}
+
+/**
+ * export type NAME = TYPE
+ */
+function exportType(name: string, type: BabelAST): $FlowFixMe {
+  return t.exportNamedDeclaration(
+    t.typeAlias(t.identifier(name), null, type),
+    [],
+    null,
+  );
+}
+
+/**
+ * export type {A, B, C}
+ */
+function exportTypes(names: $ReadOnlyArray<string>): $FlowFixMe {
+  const res = t.exportNamedDeclaration(
+    null,
+    names.map(name =>
+      t.exportSpecifier(t.identifier(name), t.identifier(name)),
+    ),
+
+    null,
+  );
+  res.exportKind = 'type';
+  return res;
+}
+
+/**
+ * declare export type NAME = VALUE
+ */
+function declareExportOpaqueType(name: string, value: string): $FlowFixMe {
+  return t.declareExportDeclaration(
+    t.declareOpaqueType(
+      t.identifier(name),
+      null,
+      t.genericTypeAnnotation(t.identifier(value)),
+    ),
+  );
+}
+
+/**
+ * import type {NAMES[0], NAMES[1], ...} from 'MODULE';
+ */
+function importTypes(
+  names: $ReadOnlyArray<string>,
+  module: string,
+): $FlowFixMe {
+  const importDeclaration = t.importDeclaration(
+    names.map(name =>
+      t.importSpecifier(t.identifier(name), t.identifier(name)),
+    ),
+    t.stringLiteral(module),
+  );
+  importDeclaration.importKind = 'type';
+  return importDeclaration;
+}
+
+/**
+ * Create an intersection type if needed.
+ *
+ * TYPES[0] & TYPES[1] & ...
+ */
+function intersectionTypeAnnotation(types: $ReadOnlyArray<BabelAST>): BabelAST {
+  invariant(
+    types.length > 0,
+    'RelayFlowBabelFactories: cannot create an intersection of 0 types',
+  );
+  return types.length === 1 ? types[0] : t.intersectionTypeAnnotation(types);
+}
+
+function lineComments(
+  ...lines: $ReadOnlyArray<string>
+): $ReadOnlyArray<$FlowFixMe> {
+  return lines.map(line => ({type: 'CommentLine', value: ' ' + line}));
+}
+
+/**
+ * $ReadOnlyArray<TYPE>
+ */
+function readOnlyArrayOfType(thing: BabelAST): $FlowFixMe {
+  return t.genericTypeAnnotation(
+    t.identifier('$ReadOnlyArray'),
+    t.typeParameterInstantiation([thing]),
+  );
+}
+
+/**
+ * +KEY: VALUE
+ */
+function readOnlyObjectTypeProperty(key: string, value: BabelAST): $FlowFixMe {
+  const prop = t.objectTypeProperty(t.identifier(key), value);
+  prop.variance = t.variance('plus');
+  return prop;
+}
+
+function stringLiteralTypeAnnotation(value: string): $FlowFixMe {
+  return t.stringLiteralTypeAnnotation(value);
+}
+
+/**
+ * Create a union type if needed.
+ *
+ * TYPES[0] | TYPES[1] | ...
+ */
+function unionTypeAnnotation(types: $ReadOnlyArray<BabelAST>): BabelAST {
+  invariant(
+    types.length > 0,
+    'RelayFlowBabelFactories: cannot create a union of 0 types',
+  );
+  return types.length === 1 ? types[0] : t.unionTypeAnnotation(types);
+}
+
+module.exports = {
+  anyTypeAlias,
+  declareExportOpaqueType,
+  exactObjectTypeAnnotation,
+  inexactObjectTypeAnnotation,
+  exportType,
+  exportTypes,
+  importTypes,
+  intersectionTypeAnnotation,
+  lineComments,
+  readOnlyArrayOfType,
+  readOnlyObjectTypeProperty,
+  stringLiteralTypeAnnotation,
+  unionTypeAnnotation,
+};