relay-compiler 8.0.0 → 10.0.1

package/language/javascript/RelayFlowTypeTransformers.js.flow

@@ -0,0 +1,184 @@
+/**
+ * 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 t = require('@babel/types');
+
+const {
+  exactObjectTypeAnnotation,
+  readOnlyArrayOfType,
+} = require('./RelayFlowBabelFactories');
+
+import type {Schema, TypeID, EnumTypeID} from '../../core/Schema';
+
+export type BabelTypes = typeof t;
+export type ScalarTypeMapping = {
+  [type: string]: string | (BabelTypes => mixed),
+  ...,
+};
+
+import type {State} from './RelayFlowGenerator';
+
+function getInputObjectTypeIdentifier(schema: Schema, typeID: TypeID): string {
+  return schema.getTypeString(typeID);
+}
+
+function transformScalarType(
+  schema: Schema,
+  type: TypeID,
+  state: State,
+  objectProps?: mixed,
+): mixed {
+  if (schema.isNonNull(type)) {
+    return transformNonNullableScalarType(
+      schema,
+      schema.getNullableType(type),
+      state,
+      objectProps,
+    );
+  } else {
+    return t.nullableTypeAnnotation(
+      transformNonNullableScalarType(schema, type, state, objectProps),
+    );
+  }
+}
+
+function transformNonNullableScalarType(
+  schema: Schema,
+  type: TypeID,
+  state: State,
+  objectProps,
+) {
+  if (schema.isList(type)) {
+    return readOnlyArrayOfType(
+      transformScalarType(
+        schema,
+        schema.getListItemType(type),
+        state,
+        objectProps,
+      ),
+    );
+  } else if (
+    schema.isObject(type) ||
+    schema.isUnion(type) ||
+    schema.isInterface(type)
+  ) {
+    return objectProps;
+  } else if (schema.isScalar(type)) {
+    return transformGraphQLScalarType(schema.getTypeString(type), state);
+  } else if (schema.isEnum(type)) {
+    return transformGraphQLEnumType(schema, schema.assertEnumType(type), state);
+  } else {
+    throw new Error(`Could not convert from GraphQL type ${String(type)}`);
+  }
+}
+
+function transformGraphQLScalarType(typeName: string, state: State) {
+  const customType = state.customScalars[typeName];
+  if (typeof customType === 'function') {
+    return customType(t);
+  }
+  switch (customType ?? typeName) {
+    case 'ID':
+    case 'String':
+      return t.stringTypeAnnotation();
+    case 'Float':
+    case 'Int':
+      return t.numberTypeAnnotation();
+    case 'Boolean':
+      return t.booleanTypeAnnotation();
+    default:
+      return customType == null
+        ? t.anyTypeAnnotation()
+        : t.genericTypeAnnotation(t.identifier(customType));
+  }
+}
+
+function transformGraphQLEnumType(
+  schema: Schema,
+  type: EnumTypeID,
+  state: State,
+) {
+  state.usedEnums[schema.getTypeString(type)] = type;
+  return t.genericTypeAnnotation(t.identifier(schema.getTypeString(type)));
+}
+
+function transformInputType(
+  schema: Schema,
+  type: TypeID,
+  state: State,
+): $FlowFixMe {
+  if (schema.isNonNull(type)) {
+    return transformNonNullableInputType(
+      schema,
+      schema.getNullableType(type),
+      state,
+    );
+  } else {
+    return t.nullableTypeAnnotation(
+      transformNonNullableInputType(schema, type, state),
+    );
+  }
+}
+
+function transformNonNullableInputType(
+  schema: Schema,
+  type: TypeID,
+  state: State,
+) {
+  if (schema.isList(type)) {
+    return readOnlyArrayOfType(
+      transformInputType(schema, schema.getListItemType(type), state),
+    );
+  } else if (schema.isScalar(type)) {
+    return transformGraphQLScalarType(schema.getTypeString(type), state);
+  } else if (schema.isEnum(type)) {
+    return transformGraphQLEnumType(schema, schema.assertEnumType(type), state);
+  } else if (schema.isInputObject(type)) {
+    const typeIdentifier = getInputObjectTypeIdentifier(schema, type);
+    if (state.generatedInputObjectTypes[typeIdentifier]) {
+      return t.genericTypeAnnotation(t.identifier(typeIdentifier));
+    }
+    state.generatedInputObjectTypes[typeIdentifier] = 'pending';
+    const fields = schema.getFields(schema.assertInputObjectType(type));
+    const props = fields.map(fieldID => {
+      const fieldType = schema.getFieldType(fieldID);
+      const fieldName = schema.getFieldName(fieldID);
+      const property = t.objectTypeProperty(
+        t.identifier(fieldName),
+        transformInputType(schema, fieldType, state),
+      );
+      if (
+        state.optionalInputFields.indexOf(fieldName) >= 0 ||
+        !schema.isNonNull(fieldType)
+      ) {
+        property.optional = true;
+      }
+      return property;
+    });
+
+    state.generatedInputObjectTypes[typeIdentifier] = exactObjectTypeAnnotation(
+      props,
+    );
+    return t.genericTypeAnnotation(t.identifier(typeIdentifier));
+  } else {
+    throw new Error(
+      `Could not convert from GraphQL type ${schema.getTypeString(type)}`,
+    );
+  }
+}
+
+module.exports = {
+  transformInputType,
+  transformScalarType,
+};

package/language/javascript/RelayLanguagePluginJavaScript.js.flow

@@ -0,0 +1,34 @@
+/**
+ * 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 RelayFlowGenerator = require('./RelayFlowGenerator');
+
+const {find} = require('./FindGraphQLTags');
+const {
+  formatGeneratedCommonjsModule,
+  formatGeneratedESModule,
+} = require('./formatGeneratedModule');
+
+import type {PluginInterface} from '../RelayLanguagePluginInterface';
+
+module.exports = (options?: {|eagerESModules: boolean|}): PluginInterface => ({
+  inputExtensions: ['js', 'jsx'],
+  outputExtension: 'js',
+  typeGenerator: RelayFlowGenerator,
+  formatModule:
+    options && options.eagerESModules
+      ? formatGeneratedESModule
+      : formatGeneratedCommonjsModule,
+  findGraphQLTags: find,
+});

package/language/javascript/formatGeneratedModule.js.flow

@@ -0,0 +1,65 @@
+/**
+ * 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 {FormatModule} from '../RelayLanguagePluginInterface';
+
+const formatGeneratedModule: FormatModule = ({
+  moduleName,
+  documentType,
+  docText,
+  concreteText,
+  typeText,
+  hash,
+  sourceHash,
+}) => {
+  const documentTypeImport = documentType
+    ? `import type { ${documentType} } from 'relay-runtime';`
+    : '';
+  const docTextComment =
+    docText != null ? '\n/*\n' + docText.trim() + '\n*/\n' : '';
+  const hashText = hash != null ? `\n * ${hash}` : '';
+  return `/**
+ * ${'@'}flow${hashText}
+ */
+
+/* eslint-disable */
+
+'use strict';
+
+/*::
+${documentTypeImport}
+${typeText || ''}
+*/
+
+${docTextComment}
+const node/*: ${documentType || 'empty'}*/ = ${concreteText};
+// prettier-ignore
+(node/*: any*/).hash = '${sourceHash}';
+`;
+};
+
+const formatGeneratedCommonjsModule: FormatModule = options => {
+  return `${formatGeneratedModule(options)}
+module.exports = node;
+`;
+};
+
+const formatGeneratedESModule: FormatModule = options => {
+  return `${formatGeneratedModule(options)}
+export default node;
+`;
+};
+
+exports.formatGeneratedCommonjsModule = formatGeneratedCommonjsModule;
+exports.formatGeneratedESModule = formatGeneratedESModule;

package/lib/bin/RelayCompilerBin.js

@@ -10,7 +10,7 @@
 // flowlint ambiguous-object-type:error
 'use strict';
 
-var yargs = require('yargs');
+var _yargs = require('yargs');
 
 var _require = require('./RelayCompilerMain'),
     main = _require.main;
@@ -89,6 +89,11 @@ var options = {
     type: 'string',
     array: false
   },
+  repersist: {
+    describe: 'Run the persist function even if the query has not changed.',
+    type: 'boolean',
+    "default": false
+  },
   noFutureProofEnums: {
     describe: '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.',
     type: 'boolean',
@@ -110,15 +115,27 @@ var options = {
   customScalars: {
     describe: 'Mappings from custom scalars in your schema to built-in GraphQL ' + 'types, for type emission purposes. (Uses yargs dot-notation, e.g. ' + '--customScalars.URL=String)',
     type: 'object'
+  },
+  eagerESModules: {
+    describe: 'This option enables emitting es modules artifacts.',
+    type: 'boolean',
+    "default": false
   }
-}; // Load external config
+}; // Parse CLI args
+
+var yargs = _yargs.usage('Create Relay generated files\n\n' + '$0 --schema <path> --src <path> [--watch]').options(options).strict(); // Load external config
+
+
+var config = RelayConfig && RelayConfig.loadConfig();
 
-var config = RelayConfig && RelayConfig.loadConfig(); // Parse CLI args
+if (config) {
+  // Apply externally loaded config through the yargs API so that we can leverage yargs' defaults and have them show up
+  // in the help banner. We add it conditionally otherwise yargs would add new option `--config` which is confusing for
+  // Relay users (it's not Relay Config file).
+  yargs = yargs.config(config);
+}
 
-var argv = yargs.usage('Create Relay generated files\n\n' + '$0 --schema <path> --src <path> [--watch]') // $FlowFixMe - TODO @alloy (OSS): Fix non-existent 'object' type for parsing customScalars config
-.options(options) // Apply externally loaded config through the yargs API so that we can leverage yargs' defaults and have them show up
-// in the help banner.
-.config(config).help().argv; // Start the application
+var argv = yargs.help().argv; // Start the application
 
 main(argv)["catch"](function (error) {
   console.error(String(error.stack || error));