@ardatan/relay-compiler 12.0.0

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 => BabelNode_DEPRECATED),
+  ...,
+};
+
+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?: BabelNode_DEPRECATED,
+): BabelNode_DEPRECATED {
+  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,
+): BabelNode_DEPRECATED {
+  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,
+): BabelNode_DEPRECATED {
+  state.usedEnums[schema.getTypeString(type)] = type;
+  return t.genericTypeAnnotation(t.identifier(schema.getTypeString(type)));
+}
+
+function transformInputType(
+  schema: Schema,
+  type: TypeID,
+  state: State,
+): BabelNode_DEPRECATED {
+  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,
+): BabelNode_DEPRECATED {
+  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

@@ -0,0 +1,143 @@
+/**
+ * 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.
+ *
+ * 
+ * @format
+ */
+// flowlint ambiguous-object-type:error
+'use strict';
+
+var _yargs = require('yargs');
+
+var _require = require('./RelayCompilerMain'),
+    main = _require.main;
+
+var RelayConfig;
+
+try {
+  // eslint-disable-next-line no-eval
+  RelayConfig = eval('require')('relay-config'); // eslint-disable-next-line lint/no-unused-catch-bindings
+} catch (_) {}
+
+var options = {
+  schema: {
+    describe: 'Path to schema.graphql or schema.json',
+    demandOption: true,
+    type: 'string',
+    array: false
+  },
+  src: {
+    describe: 'Root directory of application code',
+    demandOption: true,
+    type: 'string',
+    array: false
+  },
+  include: {
+    describe: 'Directories to include under src',
+    type: 'string',
+    array: true,
+    "default": ['**']
+  },
+  exclude: {
+    describe: 'Directories to ignore under src',
+    type: 'string',
+    array: true,
+    "default": ['**/node_modules/**', '**/__mocks__/**', '**/__generated__/**']
+  },
+  extensions: {
+    array: true,
+    describe: 'File extensions to compile (defaults to extensions provided by the ' + 'language plugin)',
+    type: 'string'
+  },
+  verbose: {
+    describe: 'More verbose logging',
+    type: 'boolean',
+    "default": false
+  },
+  quiet: {
+    describe: 'No output to stdout',
+    type: 'boolean',
+    "default": false
+  },
+  watchman: {
+    describe: 'Use watchman when not in watch mode',
+    type: 'boolean',
+    "default": true
+  },
+  watch: {
+    describe: 'If specified, watches files and regenerates on changes',
+    type: 'boolean',
+    "default": false
+  },
+  validate: {
+    describe: 'Looks for pending changes and exits with non-zero code instead of ' + 'writing to disk',
+    type: 'boolean',
+    "default": false
+  },
+  persistFunction: {
+    describe: 'An async function (or path to a module exporting this function) which will persist the query text and return the id.',
+    demandOption: false,
+    type: 'string',
+    array: false
+  },
+  persistOutput: {
+    describe: 'A path to a .json file where persisted query metadata should be saved. Will use the default implementation (md5 hash) if `persistFunction` is not passed.',
+    demandOption: false,
+    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',
+    "default": false
+  },
+  language: {
+    describe: 'The name of the language plugin used for input files and artifacts',
+    demandOption: false,
+    type: 'string',
+    array: false,
+    "default": 'javascript'
+  },
+  artifactDirectory: {
+    describe: 'A specific directory to output all artifacts to. When enabling this ' + 'the babel plugin needs `artifactDirectory` set as well.',
+    demandOption: false,
+    type: 'string',
+    array: false
+  },
+  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
+  }
+}; // 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();
+
+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.help().argv; // Start the application
+
+main(argv)["catch"](function (error) {
+  console.error(String(error.stack || error));
+  process.exit(1);
+});