relay-compiler 11.0.2 → 13.0.0-rc.2

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

@@ -1,189 +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 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) &&
-      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, fragment.type);
-  // 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

@@ -1,219 +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 SchemaUtils = require('../../core/SchemaUtils');
-
-const nullthrows = require('nullthrows');
-
-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;
-  }
-  const idField = schema.getFieldByName(fragment.type, 'id');
-  const nodeType = schema.assertCompositeType(
-    nullthrows(schema.getTypeFromString(NODE_TYPE_NAME)),
-  );
-  const generatedIDSelection = idField
-    ? SchemaUtils.generateIDField(schema, fragment.type)
-    : {
-        kind: 'InlineFragment',
-        directives: [],
-        loc: {kind: 'Generated'},
-        metadata: null,
-        selections: [SchemaUtils.generateIDField(schema, nodeType)],
-        typeCondition: nodeType,
-      };
-  return {
-    ...fragment,
-    selections: [...fragment.selections, generatedIDSelection],
-  };
-}
-
-module.exports = ({
-  description: 'the Node interface or types implementing the Node interface',
-  buildRefetchOperation,
-}: QueryGenerator);

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

@@ -1,57 +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 {
-  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

@@ -1,97 +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 {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

@@ -1,90 +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 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,
-};