@ardatan/relay-compiler 12.0.0

package/transforms/DeclarativeConnectionMutationTransform.js.flow

@@ -0,0 +1,250 @@
+/**
+ * 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 IRTransformer = require('../core/IRTransformer');
+
+const {createUserError} = require('../core/CompilerError');
+const {ConnectionInterface} = require('relay-runtime');
+
+const DELETE_RECORD = 'deleteRecord';
+const DELETE_EDGE = 'deleteEdge';
+const APPEND_EDGE = 'appendEdge';
+const PREPEND_EDGE = 'prependEdge';
+const APPEND_NODE = 'appendNode';
+const PREPEND_NODE = 'prependNode';
+const EDGE_LINKED_FIELD_DIRECTIVES = [APPEND_EDGE, PREPEND_EDGE];
+const NODE_LINKED_FIELD_DIRECTIVES = [APPEND_NODE, PREPEND_NODE];
+const LINKED_FIELD_DIRECTIVES = [
+  ...EDGE_LINKED_FIELD_DIRECTIVES,
+  ...NODE_LINKED_FIELD_DIRECTIVES,
+];
+
+const SCHEMA_EXTENSION = `
+  directive @${DELETE_RECORD} on FIELD
+  directive @${DELETE_EDGE}(
+    connections: [ID!]!
+  ) on FIELD
+  directive @${APPEND_EDGE}(
+    connections: [ID!]!
+  ) on FIELD
+  directive @${PREPEND_EDGE}(
+    connections: [ID!]!
+  ) on FIELD
+  directive @${APPEND_NODE}(
+    connections: [ID!]!
+    edgeTypeName: String!
+  ) on FIELD
+  directive @${PREPEND_NODE}(
+    connections: [ID!]!
+    edgeTypeName: String!
+  ) on FIELD
+`;
+
+import type CompilerContext from '../core/CompilerContext';
+import type {ScalarField, LinkedField, Root, Handle} from '../core/IR';
+
+function transform(context: CompilerContext): CompilerContext {
+  return IRTransformer.transform(context, {
+    ScalarField: visitScalarField,
+    LinkedField: visitLinkedField,
+    SplitOperation: skip,
+    Fragment: skip,
+  });
+}
+
+function skip<T>(node: T): T {
+  return node;
+}
+
+function visitScalarField(field: ScalarField): ScalarField {
+  const linkedFieldDirective = field.directives.find(
+    directive => LINKED_FIELD_DIRECTIVES.indexOf(directive.name) > -1,
+  );
+  if (linkedFieldDirective != null) {
+    throw createUserError(
+      `Invalid use of @${linkedFieldDirective.name} on scalar field '${field.name}'`,
+      [linkedFieldDirective.loc],
+    );
+  }
+  const deleteNodeDirective = field.directives.find(
+    directive => directive.name === DELETE_RECORD,
+  );
+  const deleteEdgeDirective = field.directives.find(
+    directive => directive.name === DELETE_EDGE,
+  );
+  if (deleteNodeDirective != null && deleteEdgeDirective != null) {
+    throw createUserError(
+      `Both @deleteNode and @deleteEdge are used on field '${field.name}'. Only one directive is supported for now.`,
+      [deleteNodeDirective.loc, deleteEdgeDirective.loc],
+    );
+  }
+  const targetDirective = deleteNodeDirective ?? deleteEdgeDirective;
+  if (targetDirective == null) {
+    return field;
+  }
+
+  // $FlowFixMe[incompatible-use]
+  const schema = this.getContext().getSchema();
+
+  if (!schema.isId(schema.getRawType(field.type))) {
+    throw createUserError(
+      `Invalid use of @${targetDirective.name} on field '${
+        field.name
+      }'. Expected field to return an ID or list of ID values, got ${schema.getTypeString(
+        field.type,
+      )}.`,
+      [targetDirective.loc],
+    );
+  }
+  const connectionsArg = targetDirective.args.find(
+    arg => arg.name === 'connections',
+  );
+  const handle: Handle = {
+    name: targetDirective.name,
+    key: '',
+    dynamicKey: null,
+    filters: null,
+    handleArgs: connectionsArg ? [connectionsArg] : undefined,
+  };
+  return {
+    ...field,
+    directives: field.directives.filter(
+      directive => directive !== targetDirective,
+    ),
+    handles: field.handles ? [...field.handles, handle] : [handle],
+  };
+}
+
+function visitLinkedField(field: LinkedField): LinkedField {
+  // $FlowFixMe[incompatible-use]
+  const transformedField = this.traverse(field);
+  const deleteDirective = transformedField.directives.find(
+    directive => directive.name === DELETE_RECORD,
+  );
+  if (deleteDirective != null) {
+    throw createUserError(
+      `Invalid use of @${deleteDirective.name} on scalar field '${transformedField.name}'.`,
+      [deleteDirective.loc],
+    );
+  }
+  const edgeDirective = transformedField.directives.find(
+    directive => EDGE_LINKED_FIELD_DIRECTIVES.indexOf(directive.name) > -1,
+  );
+  const nodeDirective = transformedField.directives.find(
+    directive => NODE_LINKED_FIELD_DIRECTIVES.indexOf(directive.name) > -1,
+  );
+
+  if (edgeDirective == null && nodeDirective == null) {
+    return transformedField;
+  }
+  if (edgeDirective != null && nodeDirective != null) {
+    throw createUserError(
+      `Invalid use of @${edgeDirective.name} and @${nodeDirective.name} on field '${transformedField.name}' - these directives cannot be used together.`,
+      [edgeDirective.loc],
+    );
+  }
+  const targetDirective = edgeDirective ?? nodeDirective;
+  const connectionsArg = targetDirective.args.find(
+    arg => arg.name === 'connections',
+  );
+  if (connectionsArg == null) {
+    throw createUserError(
+      `Expected the 'connections' argument to be defined on @${targetDirective.name}.`,
+      [targetDirective.loc],
+    );
+  }
+  // $FlowFixMe[incompatible-use]
+  const schema = this.getContext().getSchema();
+  if (edgeDirective) {
+    const fieldType = schema.getRawType(transformedField.type);
+    const fields = schema.getFields(fieldType);
+    let cursorFieldID;
+    let nodeFieldID;
+    for (const fieldID of fields) {
+      const fieldName = schema.getFieldName(fieldID);
+      if (fieldName === ConnectionInterface.get().CURSOR) {
+        cursorFieldID = fieldID;
+      } else if (fieldName === ConnectionInterface.get().NODE) {
+        nodeFieldID = fieldID;
+      }
+    }
+
+    // Edge
+    if (cursorFieldID != null && nodeFieldID != null) {
+      const handle: Handle = {
+        name: edgeDirective.name,
+        key: '',
+        dynamicKey: null,
+        filters: null,
+        handleArgs: [connectionsArg],
+      };
+      return {
+        ...transformedField,
+        directives: transformedField.directives.filter(
+          directive => directive !== edgeDirective,
+        ),
+        handles: transformedField.handles
+          ? [...transformedField.handles, handle]
+          : [handle],
+      };
+    }
+    throw createUserError(
+      `Unsupported use of @${edgeDirective.name} on field '${transformedField.name}', expected an edge field (a field with 'cursor' and 'node' selection).`,
+      [targetDirective.loc],
+    );
+  } else {
+    // Node
+    const edgeTypeNameArg = nodeDirective.args.find(
+      arg => arg.name === 'edgeTypeName',
+    );
+    if (!edgeTypeNameArg) {
+      throw createUserError(
+        `Unsupported use of @${nodeDirective.name} on field '${transformedField.name}', 'edgeTypeName' argument must be provided.`,
+        [targetDirective.loc],
+      );
+    }
+    const rawType = schema.getRawType(transformedField.type);
+    if (schema.canHaveSelections(rawType)) {
+      const handle: Handle = {
+        name: nodeDirective.name,
+        key: '',
+        dynamicKey: null,
+        filters: null,
+        handleArgs: [connectionsArg, edgeTypeNameArg],
+      };
+      return {
+        ...transformedField,
+        directives: transformedField.directives.filter(
+          directive => directive !== nodeDirective,
+        ),
+        handles: transformedField.handles
+          ? [...transformedField.handles, handle]
+          : [handle],
+      };
+    }
+    throw createUserError(
+      `Unsupported use of @${nodeDirective.name} on field '${
+        transformedField.name
+      }'. Expected an object, union or interface, but got '${schema.getTypeString(
+        transformedField.type,
+      )}'.`,
+      [nodeDirective.loc],
+    );
+  }
+}
+
+module.exports = {
+  SCHEMA_EXTENSION,
+  transform,
+};

package/transforms/DeferStreamTransform.js.flow

@@ -0,0 +1,266 @@
+/**
+ * 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 IRTransformer = require('../core/IRTransformer');
+
+const getIdentifierForArgumentValue = require('../core/getIdentifierForArgumentValue');
+const murmurHash = require('../util/murmurHash');
+
+const {createUserError} = require('../core/CompilerError');
+
+import type CompilerContext from '../core/CompilerContext';
+import type {
+  Argument,
+  Defer,
+  Directive,
+  FragmentSpread,
+  InlineFragment,
+  LinkedField,
+  ScalarField,
+  Stream,
+} from '../core/IR';
+
+type State = {|
+  +documentName: string,
+  +recordLabel: (label: string, directive: Directive) => void,
+|};
+
+/**
+ * This transform finds usages of @defer and @stream, validates them, and
+ * converts the using node to specialized IR nodes (Defer/Stream).
+ */
+function deferStreamTransform(context: CompilerContext): CompilerContext {
+  return IRTransformer.transform(
+    context,
+    {
+      // TODO: type IRTransformer to allow changing result type
+      FragmentSpread: (visitFragmentSpread: $FlowFixMe),
+      // TODO: type IRTransformer to allow changing result type
+      InlineFragment: (visitInlineFragment: $FlowFixMe),
+      // TODO: type IRTransformer to allow changing result type
+      LinkedField: (visitLinkedField: $FlowFixMe),
+      ScalarField: visitScalarField,
+    },
+    sourceNode => {
+      const labels = new Map();
+      return {
+        documentName: sourceNode.name,
+        recordLabel: (label, directive) => {
+          const prevDirective = labels.get(label);
+          if (prevDirective) {
+            const labelArg = directive.args.find(({name}) => name === 'label');
+            const prevLabelArg = prevDirective.args.find(
+              ({name}) => name === 'label',
+            );
+            const previousLocation = prevLabelArg?.loc ?? prevDirective.loc;
+            if (labelArg) {
+              throw createUserError(
+                `Invalid use of @${directive.name}, the provided label is ` +
+                  "not unique. Specify a unique 'label' as a literal string.",
+                [labelArg?.loc, previousLocation],
+              );
+            } else {
+              throw createUserError(
+                `Invalid use of @${directive.name}, could not generate a ` +
+                  "default label that is unique. Specify a unique 'label' " +
+                  'as a literal string.',
+                [directive.loc, previousLocation],
+              );
+            }
+          }
+          labels.set(label, directive);
+        },
+      };
+    },
+  );
+}
+
+function visitLinkedField(
+  field: LinkedField,
+  state: State,
+): LinkedField | Stream {
+  const context: CompilerContext = this.getContext();
+  const schema = context.getSchema();
+
+  let transformedField: LinkedField = this.traverse(field, state);
+  const streamDirective = transformedField.directives.find(
+    directive => directive.name === 'stream',
+  );
+  if (streamDirective == null) {
+    return transformedField;
+  }
+  const type = schema.getNullableType(field.type);
+  if (!schema.isList(type)) {
+    throw createUserError(
+      `Invalid use of @stream on non-plural field '${field.name}'`,
+      [streamDirective.loc],
+    );
+  }
+  transformedField = {
+    ...transformedField,
+    directives: transformedField.directives.filter(
+      directive => directive.name !== 'stream',
+    ),
+  };
+  const ifArg = streamDirective.args.find(arg => arg.name === 'if');
+  if (isLiteralFalse(ifArg)) {
+    return transformedField;
+  }
+  const initialCount = streamDirective.args.find(
+    arg => arg.name === 'initial_count',
+  );
+  if (initialCount == null) {
+    throw createUserError(
+      "Invalid use of @stream, the 'initial_count' argument is required.",
+      [streamDirective.loc],
+    );
+  }
+  const useCustomizedBatch = streamDirective.args.find(
+    arg => arg.name === 'use_customized_batch',
+  );
+
+  const label =
+    getLiteralStringArgument(streamDirective, 'label') ?? field.alias;
+  const transformedLabel = transformLabel(state.documentName, 'stream', label);
+  state.recordLabel(transformedLabel, streamDirective);
+  return {
+    if: ifArg?.value ?? null,
+    initialCount: initialCount.value,
+    useCustomizedBatch: useCustomizedBatch?.value ?? null,
+    kind: 'Stream',
+    label: transformedLabel,
+    loc: {kind: 'Derived', source: streamDirective.loc},
+    metadata: null,
+    selections: [transformedField],
+  };
+}
+
+function visitScalarField(field: ScalarField, state: State): ScalarField {
+  const streamDirective = field.directives.find(
+    directive => directive.name === 'stream',
+  );
+  if (streamDirective != null) {
+    throw createUserError(
+      `Invalid use of @stream on scalar field '${field.name}'`,
+      [streamDirective.loc],
+    );
+  }
+  // $FlowFixMe[incompatible-use]
+  return this.traverse(field, state);
+}
+
+function visitInlineFragment(
+  fragment: InlineFragment,
+  state: State,
+): InlineFragment | Defer {
+  const deferDirective = fragment.directives.find(
+    directive => directive.name === 'defer',
+  );
+  if (deferDirective != null) {
+    throw createUserError(
+      'Invalid use of @defer on an inline fragment, @defer is only supported on fragment spreads.',
+      [fragment.loc],
+    );
+  }
+  return this.traverse(fragment, state);
+}
+
+function visitFragmentSpread(
+  spread: FragmentSpread,
+  state: State,
+): FragmentSpread | Defer {
+  let transformedSpread: FragmentSpread = this.traverse(spread, state);
+  const deferDirective = transformedSpread.directives.find(
+    directive => directive.name === 'defer',
+  );
+  if (deferDirective == null) {
+    return transformedSpread;
+  }
+  transformedSpread = {
+    ...transformedSpread,
+    directives: transformedSpread.directives.filter(
+      directive => directive.name !== 'defer',
+    ),
+  };
+  const ifArg = deferDirective.args.find(arg => arg.name === 'if');
+  if (isLiteralFalse(ifArg)) {
+    return transformedSpread;
+  }
+  const label =
+    getLiteralStringArgument(deferDirective, 'label') ??
+    getFragmentSpreadName(spread);
+  const transformedLabel = transformLabel(state.documentName, 'defer', label);
+  state.recordLabel(transformedLabel, deferDirective);
+  return {
+    if: ifArg?.value ?? null,
+    kind: 'Defer',
+    label: transformedLabel,
+    loc: {kind: 'Derived', source: deferDirective.loc},
+    selections: [transformedSpread],
+  };
+}
+
+function getLiteralStringArgument(
+  directive: Directive,
+  argName: string,
+): ?string {
+  const arg = directive.args.find(({name}) => name === argName);
+  if (arg == null) {
+    return null;
+  }
+  const value = arg.value.kind === 'Literal' ? arg.value.value : null;
+  if (value == null || typeof value !== 'string') {
+    throw createUserError(
+      `Expected the '${argName}' value to @${directive.name} to be a string literal if provided.`,
+      [arg.value.loc],
+    );
+  }
+  return value;
+}
+
+function transformLabel(
+  parentName: string,
+  directive: string,
+  label: string,
+): string {
+  return `${parentName}$${directive}$${label}`;
+}
+
+function isLiteralFalse(arg: ?Argument): boolean {
+  return (
+    arg != null && arg.value.kind === 'Literal' && arg.value.value === false
+  );
+}
+
+function getFragmentSpreadName(fragmentSpread: FragmentSpread): string {
+  if (fragmentSpread.args.length === 0) {
+    return fragmentSpread.name;
+  }
+  const sortedArgs = [...fragmentSpread.args]
+    .sort((a, b) => {
+      return a.name < b.name ? -1 : a.name > b.name ? 1 : 0;
+    })
+    .map(argument => {
+      return {
+        name: argument.name,
+        value: getIdentifierForArgumentValue(argument.value),
+      };
+    });
+  const hash = murmurHash(JSON.stringify(sortedArgs));
+  return `${fragmentSpread.name}_${hash}`;
+}
+
+module.exports = {
+  transform: deferStreamTransform,
+};

package/transforms/DisallowIdAsAlias.js.flow

@@ -0,0 +1,48 @@
+/**
+ * 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 IRTransformer = require('../core/IRTransformer');
+
+const {createUserError} = require('../core/CompilerError');
+
+import type CompilerContext from '../core/CompilerContext';
+import type {ScalarField, LinkedField} from '../core/IR';
+
+function visitField<T: ScalarField | LinkedField>(field: T): T {
+  if (field.alias === 'id' && field.name !== 'id') {
+    throw createUserError(
+      'Relay does not allow aliasing fields to `id`. ' +
+        'This name is reserved for the globally unique `id` field on ' +
+        '`Node`.',
+      [field.loc],
+    );
+  }
+  // $FlowFixMe[incompatible-use]
+  return this.traverse(field);
+}
+
+/**
+ * This is not an actual transform (but more a validation)
+ * Relay does not allow aliasing fields to `id`.
+ */
+function disallowIdAsAlias(context: CompilerContext): CompilerContext {
+  return IRTransformer.transform(context, {
+    ScalarField: visitField,
+    LinkedField: visitField,
+  });
+}
+
+module.exports = {
+  transform: disallowIdAsAlias,
+};

package/transforms/DisallowTypenameOnRoot.js.flow

@@ -0,0 +1,45 @@
+/**
+ * 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 IRValidator = require('../core/IRValidator');
+
+const {createUserError} = require('../core/CompilerError');
+
+import type CompilerContext from '../core/CompilerContext';
+import type {Root} from '../core/IR';
+
+function visitRoot(node: Root) {
+  for (const selection of node.selections) {
+    if (selection.kind === 'ScalarField' && selection.name === '__typename') {
+      throw createUserError(
+        'Relay does not allow `__typename` field on Query, Mutation or Subscription',
+        [selection.loc],
+      );
+    }
+  }
+}
+
+function stopVisit() {}
+
+function disallowTypenameOnRoot(context: CompilerContext): CompilerContext {
+  IRValidator.validate(context, {
+    Root: visitRoot,
+    Fragment: stopVisit,
+  });
+  return context;
+}
+
+module.exports = {
+  transform: disallowTypenameOnRoot,
+};

package/transforms/FieldHandleTransform.js.flow

@@ -0,0 +1,81 @@
+/**
+ * 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 IRTransformer = require('../core/IRTransformer');
+const SchemaUtils = require('../core/SchemaUtils');
+
+const invariant = require('invariant');
+const nullthrows = require('nullthrows');
+
+const {getRelayHandleKey} = require('relay-runtime');
+
+import type CompilerContext from '../core/CompilerContext';
+import type {LinkedField, ScalarField} from '../core/IR';
+
+function fieldHandleTransform(context: CompilerContext): CompilerContext {
+  return IRTransformer.transform(context, {
+    LinkedField: visitField,
+    ScalarField: visitField,
+  });
+}
+
+/**
+ * @internal
+ */
+function visitField<F: LinkedField | ScalarField>(field: F): F {
+  // $FlowFixMe[incompatible-use]
+  const nextField = field.kind === 'LinkedField' ? this.traverse(field) : field;
+  const handles = nextField.handles;
+  if (!handles || !handles.length) {
+    return nextField;
+  }
+  // ensure exactly one handle
+  invariant(
+    handles.length === 1,
+    'FieldHandleTransform: Expected fields to have at most one ' +
+      '"handle" property, got `%s`.',
+    handles.join(', '),
+  );
+  // $FlowFixMe[incompatible-use]
+  const context: CompilerContext = this.getContext();
+  const schema = context.getSchema();
+  const alias = nextField.alias;
+  const handle = handles[0];
+  const name = getRelayHandleKey(handle.name, handle.key, nextField.name);
+  const filters = handle.filters;
+  const args = filters
+    ? nextField.args.filter(arg => filters.indexOf(arg.name) !== -1)
+    : [];
+  if (handle.dynamicKey != null) {
+    args.push({
+      kind: 'Argument',
+      loc: handle.dynamicKey.loc,
+      name: '__dynamicKey',
+      type: SchemaUtils.getNullableStringInput(schema),
+      value: nullthrows(handle.dynamicKey),
+    });
+  }
+
+  return ({
+    ...nextField,
+    args,
+    alias,
+    name,
+    handles: null,
+  }: $FlowIssue);
+}
+
+module.exports = {
+  transform: fieldHandleTransform,
+};