relay-compiler 12.0.0 → 13.0.0

package/transforms/DeclarativeConnectionMutationTransform.js.flow

@@ -1,250 +0,0 @@
-/**
- * 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

@@ -1,266 +0,0 @@
-/**
- * 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

@@ -1,48 +0,0 @@
-/**
- * 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

@@ -1,45 +0,0 @@
-/**
- * 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

@@ -1,81 +0,0 @@
-/**
- * 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,
-};