relay-compiler 7.0.0 → 9.1.0

package/transforms/query-generators/FetchableQueryGenerator.js.flow

@@ -0,0 +1,190 @@
+/**
+ * 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 SchemaUtils = require('../../core/SchemaUtils');
+
+const {createUserError} = require('../../core/CompilerError');
+const {
+  buildFragmentSpread,
+  buildOperationArgumentDefinitions,
+} = require('./utils');
+
+import type {Fragment} from '../../core/IR';
+import type {Schema} from '../../core/Schema';
+import type {QueryGenerator, RefetchRoot} from '.';
+
+function buildRefetchOperation(
+  schema: Schema,
+  fragment: Fragment,
+  queryName: string,
+): ?RefetchRoot {
+  let fetchableIdentifierField = null;
+  if (schema.isObject(fragment.type)) {
+    const objectType = schema.assertObjectType(fragment.type);
+    fetchableIdentifierField = schema.getFetchableFieldName(objectType);
+  }
+  if (fetchableIdentifierField == null) {
+    return null;
+  }
+  const identifierField = schema.getFieldConfig(
+    schema.expectField(fragment.type, fetchableIdentifierField),
+  );
+  if (!schema.isId(schema.getRawType(identifierField.type))) {
+    const typeName = schema.getTypeString(fragment.type);
+    throw createUserError(
+      `Invalid use of @refetchable on fragment '${fragment.name}', the type ` +
+        `'${typeName}' is @fetchable but the identifying field '${fetchableIdentifierField}' ` +
+        "does not have type 'ID'.",
+      [fragment.loc],
+    );
+  }
+
+  const queryType = schema.expectQueryType();
+  const fetchFieldName = `fetch__${schema.getTypeString(fragment.type)}`;
+  const fetchField = schema.getFieldConfig(
+    schema.expectField(queryType, fetchFieldName),
+  );
+  if (
+    !(
+      fetchField != null &&
+      schema.isObject(fetchField.type) &&
+      schema.areEqualTypes(fetchField.type, fragment.type) &&
+      fetchField.args.length === 1 &&
+      schema.areEqualTypes(
+        schema.getNullableType(fetchField.args[0].type),
+        schema.expectIdType(),
+      )
+    )
+  ) {
+    const typeName = schema.getTypeString(fragment.type);
+    throw createUserError(
+      `Invalid use of @refetchable on fragment '${fragment.name}', the type ` +
+        `'${typeName}' is @fetchable but there is no corresponding '${fetchFieldName}'` +
+        `field or it is invalid (expected '${fetchFieldName}(id: ID!): ${typeName}').`,
+      [fragment.loc],
+    );
+  }
+
+  // name and type of the node(_: ID) field parameter
+  const idArgName = fetchField.args[0].name;
+  const idArgType = fetchField.args[0].type;
+  // name and type of the query variable
+  const idVariableType = SchemaUtils.getNonNullIdInput(schema);
+  const idVariableName = 'id';
+
+  const argumentDefinitions = buildOperationArgumentDefinitions(
+    fragment.argumentDefinitions,
+  );
+  const idArgument = argumentDefinitions.find(
+    argDef => argDef.name === idVariableName,
+  );
+  if (idArgument != null) {
+    throw createUserError(
+      `Invalid use of @refetchable on fragment \`${fragment.name}\`, this ` +
+        'fragment already has an `$id` variable in scope.',
+      [idArgument.loc],
+    );
+  }
+  const argumentDefinitionsWithId = [
+    ...argumentDefinitions,
+    {
+      defaultValue: null,
+      kind: 'LocalArgumentDefinition',
+      loc: {kind: 'Derived', source: fragment.loc},
+      name: idVariableName,
+      type: idVariableType,
+    },
+  ];
+  return {
+    identifierField: fetchableIdentifierField,
+    path: [fetchFieldName],
+    node: {
+      argumentDefinitions: argumentDefinitionsWithId,
+      directives: [],
+      kind: 'Root',
+      loc: {kind: 'Derived', source: fragment.loc},
+      metadata: null,
+      name: queryName,
+      operation: 'query',
+      selections: [
+        {
+          alias: fetchFieldName,
+          args: [
+            {
+              kind: 'Argument',
+              loc: {kind: 'Derived', source: fragment.loc},
+              name: idArgName,
+              type: schema.assertInputType(idArgType),
+              value: {
+                kind: 'Variable',
+                loc: {kind: 'Derived', source: fragment.loc},
+                variableName: idVariableName,
+                type: idVariableType,
+              },
+            },
+          ],
+          connection: false,
+          directives: [],
+          handles: null,
+          kind: 'LinkedField',
+          loc: {kind: 'Derived', source: fragment.loc},
+          metadata: null,
+          name: fetchFieldName,
+          selections: [buildFragmentSpread(fragment)],
+          type: fragment.type,
+        },
+      ],
+      type: queryType,
+    },
+    transformedFragment: enforceIDField(
+      schema,
+      fragment,
+      fetchableIdentifierField,
+    ),
+  };
+}
+
+function enforceIDField(
+  schema: Schema,
+  fragment: Fragment,
+  fetchableIdentifierField: string,
+): Fragment {
+  const idSelection = fragment.selections.find(
+    selection =>
+      selection.kind === 'ScalarField' &&
+      selection.name === fetchableIdentifierField &&
+      selection.alias === fetchableIdentifierField &&
+      schema.areEqualTypes(
+        schema.getNullableType(selection.type),
+        schema.expectIdType(),
+      ),
+  );
+  if (idSelection) {
+    return fragment;
+  }
+  const idField = SchemaUtils.generateIDField(schema.expectIdType());
+  // idField is uniquely owned here, safe to mutate
+  (idField: $FlowFixMe).alias = fetchableIdentifierField;
+  // idField is uniquely owned here, safe to mutate
+  (idField: $FlowFixMe).name = fetchableIdentifierField;
+  return {
+    ...fragment,
+    selections: [...fragment.selections, idField],
+  };
+}
+
+module.exports = ({
+  description: '@fetchable types',
+  buildRefetchOperation,
+}: QueryGenerator);

package/transforms/query-generators/NodeQueryGenerator.js.flow

@@ -0,0 +1,206 @@
+/**
+ * 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 SchemaUtils = require('../../core/SchemaUtils');
+
+const {createUserError} = require('../../core/CompilerError');
+const {
+  buildFragmentSpread,
+  buildOperationArgumentDefinitions,
+} = require('./utils');
+
+import type {Fragment} from '../../core/IR';
+import type {Schema} from '../../core/Schema';
+import type {QueryGenerator, RefetchRoot} from '.';
+
+const NODE_TYPE_NAME = 'Node';
+const NODE_FIELD_NAME = 'node';
+
+function buildRefetchOperation(
+  schema: Schema,
+  fragment: Fragment,
+  queryName: string,
+): ?RefetchRoot {
+  const eligible =
+    schema.getTypeString(fragment.type) === NODE_TYPE_NAME ||
+    (schema.isObject(fragment.type) &&
+      schema
+        .getInterfaces(schema.assertCompositeType(fragment.type))
+        .some(interfaceType =>
+          schema.areEqualTypes(
+            interfaceType,
+            schema.expectTypeFromString(NODE_TYPE_NAME),
+          ),
+        )) ||
+    (schema.isAbstractType(fragment.type) &&
+      Array.from(
+        schema.getPossibleTypes(schema.assertAbstractType(fragment.type)),
+      ).every(possibleType =>
+        schema.implementsInterface(
+          schema.assertCompositeType(possibleType),
+          schema.assertInterfaceType(
+            schema.expectTypeFromString(NODE_TYPE_NAME),
+          ),
+        ),
+      ));
+  if (!eligible) {
+    return null;
+  }
+
+  const queryType = schema.expectQueryType();
+  const nodeType = schema.getTypeFromString(NODE_TYPE_NAME);
+  const nodeField = schema.getFieldConfig(
+    schema.expectField(queryType, NODE_FIELD_NAME),
+  );
+  if (
+    !(
+      nodeType &&
+      schema.isInterface(nodeType) &&
+      schema.isInterface(nodeField.type) &&
+      schema.areEqualTypes(nodeField.type, nodeType) &&
+      nodeField.args.length === 1 &&
+      schema.areEqualTypes(
+        schema.getNullableType(nodeField.args[0].type),
+        schema.expectIdType(),
+      ) &&
+      // the fragment must be on Node or on a type that implements Node
+      ((schema.isObject(fragment.type) &&
+        schema
+          .getInterfaces(schema.assertCompositeType(fragment.type))
+          .some(interfaceType =>
+            schema.areEqualTypes(interfaceType, nodeType),
+          )) ||
+        (schema.isAbstractType(fragment.type) &&
+          Array.from(
+            schema.getPossibleTypes(schema.assertAbstractType(fragment.type)),
+          ).every(possibleType =>
+            schema
+              .getInterfaces(schema.assertCompositeType(possibleType))
+              .some(interfaceType =>
+                schema.areEqualTypes(interfaceType, nodeType),
+              ),
+          )))
+    )
+  ) {
+    throw createUserError(
+      `Invalid use of @refetchable on fragment '${fragment.name}', check ` +
+        'that your schema defines a `Node { id: ID }` interface and has a ' +
+        '`node(id: ID): Node` field on the query type (the id argument may ' +
+        'also be non-null).',
+      [fragment.loc],
+    );
+  }
+
+  // name and type of the node(_: ID) field parameter
+  const idArgName = nodeField.args[0].name;
+  const idArgType = nodeField.args[0].type;
+  // name and type of the query variable
+  const idVariableType = SchemaUtils.getNonNullIdInput(schema);
+  const idVariableName = 'id';
+
+  const argumentDefinitions = buildOperationArgumentDefinitions(
+    fragment.argumentDefinitions,
+  );
+  const idArgument = argumentDefinitions.find(
+    argDef => argDef.name === idVariableName,
+  );
+  if (idArgument != null) {
+    throw createUserError(
+      `Invalid use of @refetchable on fragment \`${fragment.name}\`, this ` +
+        'fragment already has an `$id` variable in scope.',
+      [idArgument.loc],
+    );
+  }
+  const argumentDefinitionsWithId = [
+    ...argumentDefinitions,
+    {
+      defaultValue: null,
+      kind: 'LocalArgumentDefinition',
+      loc: {kind: 'Derived', source: fragment.loc},
+      name: idVariableName,
+      type: idVariableType,
+    },
+  ];
+  return {
+    identifierField: 'id',
+    path: [NODE_FIELD_NAME],
+    node: {
+      argumentDefinitions: argumentDefinitionsWithId,
+      directives: [],
+      kind: 'Root',
+      loc: {kind: 'Derived', source: fragment.loc},
+      metadata: null,
+      name: queryName,
+      operation: 'query',
+      selections: [
+        {
+          alias: NODE_FIELD_NAME,
+          args: [
+            {
+              kind: 'Argument',
+              loc: {kind: 'Derived', source: fragment.loc},
+              name: idArgName,
+              type: schema.assertInputType(idArgType),
+              value: {
+                kind: 'Variable',
+                loc: {kind: 'Derived', source: fragment.loc},
+                variableName: idVariableName,
+                type: idVariableType,
+              },
+            },
+          ],
+          connection: false,
+          directives: [],
+          handles: null,
+          kind: 'LinkedField',
+          loc: {kind: 'Derived', source: fragment.loc},
+          metadata: null,
+          name: NODE_FIELD_NAME,
+          selections: [buildFragmentSpread(fragment)],
+          type: schema.assertLinkedFieldType(nodeType),
+        },
+      ],
+      type: queryType,
+    },
+    transformedFragment: enforceIDField(schema, fragment),
+  };
+}
+
+function enforceIDField(schema: Schema, fragment: Fragment): Fragment {
+  const idSelection = fragment.selections.find(
+    selection =>
+      selection.kind === 'ScalarField' &&
+      selection.name === 'id' &&
+      selection.alias === 'id' &&
+      schema.areEqualTypes(
+        schema.getNullableType(selection.type),
+        schema.expectIdType(),
+      ),
+  );
+  if (idSelection) {
+    return fragment;
+  }
+  return {
+    ...fragment,
+    selections: [
+      ...fragment.selections,
+      SchemaUtils.generateIDField(schema.expectIdType()),
+    ],
+  };
+}
+
+module.exports = ({
+  description: 'the Node interface or types implementing the Node interface',
+  buildRefetchOperation,
+}: QueryGenerator);

package/transforms/query-generators/QueryQueryGenerator.js.flow

@@ -0,0 +1,57 @@
+/**
+ * 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 {
+  buildFragmentSpread,
+  buildOperationArgumentDefinitions,
+} = require('./utils');
+
+import type {Fragment} from '../../core/IR';
+import type {Schema} from '../../core/Schema';
+import type {QueryGenerator, RefetchRoot} from '.';
+
+function buildRefetchOperation(
+  schema: Schema,
+  fragment: Fragment,
+  queryName: string,
+): ?RefetchRoot {
+  const queryType = schema.expectQueryType();
+  if (!schema.areEqualTypes(fragment.type, queryType)) {
+    return null;
+  }
+
+  return {
+    identifierField: null,
+    path: [],
+    node: {
+      argumentDefinitions: buildOperationArgumentDefinitions(
+        fragment.argumentDefinitions,
+      ),
+      directives: [],
+      kind: 'Root',
+      loc: {kind: 'Derived', source: fragment.loc},
+      metadata: null,
+      name: queryName,
+      operation: 'query',
+      selections: [buildFragmentSpread(fragment)],
+      type: queryType,
+    },
+    transformedFragment: fragment,
+  };
+}
+
+module.exports = ({
+  description: 'the query type',
+  buildRefetchOperation,
+}: QueryGenerator);

package/transforms/query-generators/ViewerQueryGenerator.js.flow

@@ -0,0 +1,97 @@
+/**
+ * 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 {createUserError} = require('../../core/CompilerError');
+const {
+  buildFragmentSpread,
+  buildOperationArgumentDefinitions,
+} = require('./utils');
+
+import type {Fragment} from '../../core/IR';
+import type {Schema} from '../../core/Schema';
+import type {QueryGenerator, RefetchRoot} from '.';
+
+const VIEWER_TYPE_NAME = 'Viewer';
+const VIEWER_FIELD_NAME = 'viewer';
+
+function buildRefetchOperation(
+  schema: Schema,
+  fragment: Fragment,
+  queryName: string,
+): ?RefetchRoot {
+  if (schema.getTypeString(fragment.type) !== VIEWER_TYPE_NAME) {
+    return null;
+  }
+  // Handle fragments on viewer
+  const queryType = schema.expectQueryType();
+  const viewerType = schema.getTypeFromString(VIEWER_TYPE_NAME);
+  const viewerField = schema.getFieldConfig(
+    schema.expectField(queryType, VIEWER_FIELD_NAME),
+  );
+  const viewerFieldType = schema.getNullableType(viewerField.type);
+  if (
+    !(
+      viewerType &&
+      schema.isObject(viewerType) &&
+      schema.isObject(viewerFieldType) &&
+      schema.areEqualTypes(viewerFieldType, viewerType) &&
+      viewerField.args.length === 0 &&
+      schema.areEqualTypes(fragment.type, viewerType)
+    )
+  ) {
+    throw createUserError(
+      `Invalid use of @refetchable on fragment '${fragment.name}', check ` +
+        "that your schema defines a 'Viewer' object type and has a " +
+        "'viewer: Viewer' field on the query type.",
+      [fragment.loc],
+    );
+  }
+  return {
+    identifierField: null,
+    path: [VIEWER_FIELD_NAME],
+    node: {
+      argumentDefinitions: buildOperationArgumentDefinitions(
+        fragment.argumentDefinitions,
+      ),
+      directives: [],
+      kind: 'Root',
+      loc: {kind: 'Derived', source: fragment.loc},
+      metadata: null,
+      name: queryName,
+      operation: 'query',
+      selections: [
+        {
+          alias: VIEWER_FIELD_NAME,
+          args: [],
+          connection: false,
+          directives: [],
+          handles: null,
+          kind: 'LinkedField',
+          loc: {kind: 'Derived', source: fragment.loc},
+          metadata: null,
+          name: VIEWER_FIELD_NAME,
+          selections: [buildFragmentSpread(fragment)],
+          type: schema.assertLinkedFieldType(viewerField.type),
+        },
+      ],
+      type: queryType,
+    },
+    transformedFragment: fragment,
+  };
+}
+
+module.exports = ({
+  description: 'the Viewer type',
+  buildRefetchOperation,
+}: QueryGenerator);

package/transforms/query-generators/index.js.flow

@@ -0,0 +1,90 @@
+/**
+ * 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 FetchableQueryGenerator = require('./FetchableQueryGenerator');
+const NodeQueryGenerator = require('./NodeQueryGenerator');
+const QueryQueryGenerator = require('./QueryQueryGenerator');
+const ViewerQueryGenerator = require('./ViewerQueryGenerator');
+
+const {createUserError} = require('../../core/CompilerError');
+
+import type {Fragment, Root} from '../../core/IR';
+import type {Schema} from '../../core/Schema';
+
+export type RefetchRoot = {|
+  identifierField: ?string,
+  path: $ReadOnlyArray<string>,
+  node: Root,
+  transformedFragment: Fragment,
+|};
+
+/**
+ * A strategy to generate queries for a given fragment. Multiple stategies
+ * can be tried, such as generating a `node(id: ID)` query or a query directly
+ * on the root query type.
+ */
+export type QueryGenerator = {|
+  /**
+   * Used to describe what fragments this QueryGenerator applies to, used in
+   * error messages.
+   */
+  +description: string,
+  /**
+   * Returns RefetchRoot or null if not applicable. Might throw a user error
+   * for an invalid schema or other problems.
+   */
+  +buildRefetchOperation: (
+    schema: Schema,
+    fragment: Fragment,
+    queryName: string,
+  ) => ?RefetchRoot,
+|};
+
+const GENERATORS = [
+  ViewerQueryGenerator,
+  QueryQueryGenerator,
+  NodeQueryGenerator,
+  FetchableQueryGenerator,
+];
+
+/**
+ * Builds a query to refetch the given fragment or throws if we have not way to
+ * generate one.
+ */
+function buildRefetchOperation(
+  schema: Schema,
+  fragment: Fragment,
+  queryName: string,
+): RefetchRoot {
+  for (const generator of GENERATORS) {
+    const refetchRoot = generator.buildRefetchOperation(
+      schema,
+      fragment,
+      queryName,
+    );
+    if (refetchRoot != null) {
+      return refetchRoot;
+    }
+  }
+  throw createUserError(
+    `Invalid use of @refetchable on fragment '${fragment.name}', only ` +
+      'supported are fragments on:\n' +
+      GENERATORS.map(generator => ` - ${generator.description}`).join('\n'),
+    [fragment.loc],
+  );
+}
+
+module.exports = {
+  buildRefetchOperation,
+};

package/transforms/query-generators/utils.js.flow

@@ -0,0 +1,72 @@
+/**
+ * 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';
+
+import type {
+  ArgumentDefinition,
+  Fragment,
+  FragmentSpread,
+  LocalArgumentDefinition,
+} from '../../core/IR';
+
+function buildFragmentSpread(fragment: Fragment): FragmentSpread {
+  const args = [];
+  for (const argDef of fragment.argumentDefinitions) {
+    if (argDef.kind !== 'LocalArgumentDefinition') {
+      continue;
+    }
+    args.push({
+      kind: 'Argument',
+      loc: {kind: 'Derived', source: argDef.loc},
+      name: argDef.name,
+      type: argDef.type,
+      value: {
+        kind: 'Variable',
+        loc: {kind: 'Derived', source: argDef.loc},
+        variableName: argDef.name,
+        type: argDef.type,
+      },
+    });
+  }
+  return {
+    args,
+    directives: [],
+    kind: 'FragmentSpread',
+    loc: {kind: 'Derived', source: fragment.loc},
+    metadata: null,
+    name: fragment.name,
+  };
+}
+
+function buildOperationArgumentDefinitions(
+  argumentDefinitions: $ReadOnlyArray<ArgumentDefinition>,
+): $ReadOnlyArray<LocalArgumentDefinition> {
+  return argumentDefinitions.map(argDef => {
+    if (argDef.kind === 'LocalArgumentDefinition') {
+      return argDef;
+    } else {
+      return {
+        kind: 'LocalArgumentDefinition',
+        name: argDef.name,
+        type: argDef.type,
+        defaultValue: null,
+        loc: argDef.loc,
+      };
+    }
+  });
+}
+
+module.exports = {
+  buildFragmentSpread,
+  buildOperationArgumentDefinitions,
+};