@ardatan/relay-compiler 12.0.0

package/codegen/writeRelayGeneratedFile.js.flow

@@ -0,0 +1,239 @@
+/**
+ * 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 CodeMarker = require('../util/CodeMarker');
+
+const createPrintRequireModuleDependency = require('./createPrintRequireModuleDependency');
+const dedupeJSONStringify = require('../util/dedupeJSONStringify');
+const invariant = require('invariant');
+const md5 = require('../util/md5');
+
+const {RelayConcreteNode} = require('relay-runtime');
+
+import type {GeneratedDefinition} from '../core/IR';
+import type {Schema} from '../core/Schema';
+import type {
+  FormatModule,
+  PluginInterface,
+} from '../language/RelayLanguagePluginInterface';
+import type CodegenDirectory from './CodegenDirectory';
+import type {GeneratedNode, RequestParameters} from 'relay-runtime';
+
+function getConcreteType(node: GeneratedNode): string {
+  switch (node.kind) {
+    case RelayConcreteNode.FRAGMENT:
+      return 'ReaderFragment';
+    case RelayConcreteNode.REQUEST:
+      return 'ConcreteRequest';
+    case RelayConcreteNode.SPLIT_OPERATION:
+      return 'NormalizationSplitOperation';
+    case RelayConcreteNode.INLINE_DATA_FRAGMENT:
+      return 'ReaderInlineDataFragment';
+    default:
+      (node: empty);
+      invariant(false, 'Unexpected GeneratedNode kind: `%s`.', node.kind);
+  }
+}
+
+function writeRelayGeneratedFile(
+  schema: Schema,
+  codegenDir: CodegenDirectory,
+  definition: GeneratedDefinition,
+  _generatedNode: GeneratedNode,
+  formatModule: FormatModule,
+  typeText: string,
+  _persistQuery: ?(text: string) => Promise<string>,
+  sourceHash: string,
+  extension: string,
+  printModuleDependency: (
+    moduleName: string,
+  ) => string = createPrintRequireModuleDependency(),
+  shouldRepersist: boolean,
+  writeQueryParameters: (
+    dir: CodegenDirectory,
+    filename: string,
+    moduleName: string,
+    params: RequestParameters,
+  ) => void,
+  languagePlugin: ?PluginInterface,
+): Promise<?GeneratedNode> {
+  let generatedNode: GeneratedNode = _generatedNode;
+  // Copy to const so Flow can refine.
+  const persistQuery = _persistQuery;
+  const operationName =
+    generatedNode.kind === 'Request'
+      ? generatedNode.params.name
+      : generatedNode.name;
+  const moduleName = languagePlugin?.getModuleName
+    ? languagePlugin.getModuleName(operationName)
+    : operationName + '.graphql';
+
+  const filename = moduleName + '.' + extension;
+  const queryParametersFilename =
+    generatedNode.kind === 'Request'
+      ? `${generatedNode.params.name}$Parameters.${extension}`
+      : null;
+
+  const typeName = getConcreteType(generatedNode);
+
+  let docText;
+  if (generatedNode.kind === RelayConcreteNode.REQUEST) {
+    docText =
+      generatedNode.params.text != null ? generatedNode.params.text : null;
+  }
+
+  // Use `Promise.resolve` to work around a Babel 7.8/7.9 issue.
+  return Promise.resolve().then(async () => {
+    let hash = null;
+    if (generatedNode.kind === RelayConcreteNode.REQUEST) {
+      invariant(
+        docText != null,
+        'writeRelayGeneratedFile: Expected `text` for operations to be set.',
+      );
+
+      const {
+        isRefetchableQuery: _ignored,
+        derivedFrom: _ignored2,
+        ...nextMetadata
+      } = generatedNode.params.metadata;
+
+      let nextRequestParams;
+      if (persistQuery != null) {
+        hash = md5(docText);
+
+        let id = null;
+        if (!shouldRepersist) {
+          // Unless we `shouldRepersist` the query, check if the @relayHash matches
+          // the operation text of the current text and re-use the persisted
+          // operation id.
+          const oldContent = codegenDir.read(filename);
+          const oldHash = extractHash(oldContent);
+          const oldRequestID = extractRelayRequestID(oldContent);
+          if (hash === oldHash && oldRequestID != null) {
+            id = oldRequestID;
+          }
+        }
+        if (id == null) {
+          // $FlowFixMe[incompatible-call]
+          id = await persistQuery(docText);
+        }
+        nextRequestParams = {
+          id,
+          metadata: nextMetadata,
+          // $FlowFixMe[prop-missing]
+          // $FlowFixMe[incompatible-use]
+          name: generatedNode.params.name,
+          // $FlowFixMe[prop-missing]
+          // $FlowFixMe[incompatible-use]
+          operationKind: generatedNode.params.operationKind,
+          text: null,
+        };
+      } else {
+        nextRequestParams = {
+          cacheID: md5(docText),
+          id: null,
+          metadata: nextMetadata,
+          // $FlowFixMe[prop-missing]
+          // $FlowFixMe[incompatible-use]
+          name: generatedNode.params.name,
+          // $FlowFixMe[prop-missing]
+          // $FlowFixMe[incompatible-use]
+          operationKind: generatedNode.params.operationKind,
+          text: docText,
+        };
+      }
+      // $FlowFixMe[incompatible-type]
+      generatedNode = {
+        ...generatedNode,
+        // $FlowFixMe[incompatible-type]
+        params: nextRequestParams,
+      };
+    }
+
+    // Strip metadata only used within the compiler
+    if (
+      generatedNode.kind === RelayConcreteNode.SPLIT_OPERATION &&
+      generatedNode.metadata?.derivedFrom != null
+    ) {
+      const {derivedFrom: _ignored, ...metadata} = generatedNode.metadata;
+      // $FlowFixMe[incompatible-type]
+      generatedNode = {
+        ...generatedNode,
+        metadata,
+      };
+    }
+
+    const moduleText = formatModule({
+      moduleName,
+      documentType: typeName,
+      definition,
+      kind: generatedNode.kind,
+      docText,
+      typeText,
+      hash: hash != null ? `@relayHash ${hash}` : null,
+      concreteText: CodeMarker.postProcess(
+        dedupeJSONStringify(generatedNode),
+        printModuleDependency,
+      ),
+      sourceHash,
+      // $FlowFixMe[incompatible-call]
+      node: generatedNode,
+      schema,
+    });
+    codegenDir.writeFile(filename, moduleText, shouldRepersist);
+    if (
+      writeQueryParameters &&
+      queryParametersFilename != null &&
+      generatedNode.kind === RelayConcreteNode.REQUEST &&
+      // $FlowFixMe[incompatible-type]
+      generatedNode.params.operationKind === 'query'
+    ) {
+      writeQueryParameters(
+        codegenDir,
+        queryParametersFilename,
+        moduleName,
+        // $FlowFixMe[incompatible-call]
+        generatedNode.params,
+      );
+    }
+    // $FlowFixMe[incompatible-call]
+    return generatedNode;
+  });
+}
+
+function extractHash(text: ?string): ?string {
+  if (text == null || text.length === 0) {
+    return null;
+  }
+  if (/<<<<<|>>>>>/.test(text)) {
+    // looks like a merge conflict
+    return null;
+  }
+  const match = text.match(/@relayHash (\w{32})\b/m);
+  return match && match[1];
+}
+
+function extractRelayRequestID(text: ?string): ?string {
+  if (text == null || text.length === 0) {
+    return null;
+  }
+  if (/<<<<<|>>>>>/.test(text)) {
+    // looks like a merge conflict
+    return null;
+  }
+  const match = text.match(/@relayRequestID (.+)/);
+  return match ? match[1] : null;
+}
+
+module.exports = writeRelayGeneratedFile;

package/core/ASTCache.js.flow

@@ -0,0 +1,74 @@
+/**
+ * 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
+ * @format
+ */
+
+// flowlint ambiguous-object-type:error
+
+'use strict';
+
+const Profiler = require('./GraphQLCompilerProfiler');
+
+// $FlowFixMe[untyped-import] : Immutable is not typed
+const {Map: ImmutableMap} = require('immutable');
+
+import type {File} from '../codegen/CodegenTypes';
+import type {DocumentNode} from 'graphql';
+
+type ParseFn = (baseDir: string, file: File) => ?DocumentNode;
+
+class ASTCache {
+  _documents: Map<string, DocumentNode>;
+
+  _baseDir: string;
+  _parse: ParseFn;
+
+  constructor(config: {baseDir: string, parse: ParseFn, ...}) {
+    this._documents = new Map();
+    this._baseDir = config.baseDir;
+    this._parse = Profiler.instrument(config.parse, 'ASTCache.parseFn');
+  }
+
+  // Short-term: we don't do subscriptions/delta updates, instead always use all definitions
+  // $FlowFixMe[value-as-type]
+  documents(): ImmutableMap<string, DocumentNode> {
+    return ImmutableMap(this._documents);
+  }
+
+  // parse should return the set of changes
+  parseFiles(files: Set<File>): ImmutableMap<string, DocumentNode> {
+    let documents = ImmutableMap();
+
+    files.forEach(file => {
+      if (!file.exists) {
+        this._documents.delete(file.relPath);
+        return;
+      }
+
+      const doc = (() => {
+        try {
+          return this._parse(this._baseDir, file);
+        } catch (error) {
+          throw new Error(`Parse error: ${error} in "${file.relPath}"`);
+        }
+      })();
+
+      if (!doc) {
+        this._documents.delete(file.relPath);
+        return;
+      }
+
+      documents = documents.set(file.relPath, doc);
+      this._documents.set(file.relPath, doc);
+    });
+
+    return documents;
+  }
+}
+
+module.exports = ASTCache;

package/core/ASTConvert.js.flow

@@ -0,0 +1,233 @@
+/**
+ * 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
+ * @format
+ */
+
+// flowlint ambiguous-object-type:error
+
+'use strict';
+
+const Profiler = require('./GraphQLCompilerProfiler');
+
+const {
+  isExecutableDefinitionAST,
+  isSchemaDefinitionAST,
+} = require('./SchemaUtils');
+const {extendSchema, parse, print, visit} = require('graphql');
+
+import type {Fragment, Root} from './IR';
+import type {Schema} from './Schema';
+import type {
+  DefinitionNode,
+  DocumentNode,
+  FragmentDefinitionNode,
+  FragmentSpreadNode,
+  GraphQLSchema,
+  OperationDefinitionNode,
+  TypeSystemDefinitionNode,
+  TypeSystemExtensionNode,
+} from 'graphql';
+
+type ASTDefinitionNode = FragmentDefinitionNode | OperationDefinitionNode;
+type TransformFn = (
+  schema: Schema,
+  definitions: $ReadOnlyArray<ASTDefinitionNode>,
+) => $ReadOnlyArray<Root | Fragment>;
+
+function convertASTDocuments(
+  schema: Schema,
+  documents: $ReadOnlyArray<DocumentNode>,
+  transform: TransformFn,
+): $ReadOnlyArray<Fragment | Root> {
+  return Profiler.run('ASTConvert.convertASTDocuments', () => {
+    const definitions = definitionsFromDocuments(documents);
+
+    const astDefinitions: Array<ASTDefinitionNode> = [];
+    documents.forEach(doc => {
+      doc.definitions.forEach(definition => {
+        if (isExecutableDefinitionAST(definition)) {
+          astDefinitions.push(definition);
+        }
+      });
+    });
+
+    return convertASTDefinitions(schema, definitions, transform);
+  });
+}
+
+function convertASTDocumentsWithBase(
+  schema: Schema,
+  baseDocuments: $ReadOnlyArray<DocumentNode>,
+  documents: $ReadOnlyArray<DocumentNode>,
+  transform: TransformFn,
+): $ReadOnlyArray<Fragment | Root> {
+  return Profiler.run('ASTConvert.convertASTDocumentsWithBase', () => {
+    const baseDefinitions = definitionsFromDocuments(baseDocuments);
+    const definitions = definitionsFromDocuments(documents);
+
+    const requiredDefinitions = new Map();
+    const baseMap: Map<string, ASTDefinitionNode> = new Map();
+    baseDefinitions.forEach(definition => {
+      if (isExecutableDefinitionAST(definition)) {
+        const definitionName = definition.name && definition.name.value;
+        // If there's no name, no reason to put in the map
+        if (definitionName != null) {
+          if (baseMap.has(definitionName)) {
+            throw new Error(`Duplicate definition of '${definitionName}'.`);
+          }
+          baseMap.set(definitionName, definition);
+        }
+      }
+    });
+
+    const definitionsToVisit: Array<ASTDefinitionNode> = [];
+    definitions.forEach(definition => {
+      if (isExecutableDefinitionAST(definition)) {
+        definitionsToVisit.push(definition);
+      }
+    });
+    while (definitionsToVisit.length > 0) {
+      const definition = definitionsToVisit.pop();
+      const name = definition.name && definition.name.value;
+      if (name == null) {
+        continue;
+      }
+      if (requiredDefinitions.has(name)) {
+        if (requiredDefinitions.get(name) !== definition) {
+          throw new Error(`Duplicate definition of '${name}'.`);
+        }
+        continue;
+      }
+      requiredDefinitions.set(name, definition);
+      visit(definition, {
+        FragmentSpread(spread: FragmentSpreadNode) {
+          const baseDefinition = baseMap.get(spread.name.value);
+          if (baseDefinition) {
+            // We only need to add those definitions not already included
+            // in definitions
+            definitionsToVisit.push(baseDefinition);
+          }
+        },
+      });
+    }
+
+    const definitionsToConvert = [];
+    requiredDefinitions.forEach(definition =>
+      definitionsToConvert.push(definition),
+    );
+    return convertASTDefinitions(schema, definitionsToConvert, transform);
+  });
+}
+
+function convertASTDefinitions(
+  schema: Schema,
+  definitions: $ReadOnlyArray<DefinitionNode>,
+  transform: TransformFn,
+): $ReadOnlyArray<Fragment | Root> {
+  const operationDefinitions: Array<ASTDefinitionNode> = [];
+  definitions.forEach(definition => {
+    if (isExecutableDefinitionAST(definition)) {
+      operationDefinitions.push(definition);
+    }
+  });
+  return transform(schema, operationDefinitions);
+}
+
+function definitionsFromDocuments(
+  documents: $ReadOnlyArray<DocumentNode>,
+): $ReadOnlyArray<DefinitionNode> {
+  const definitions = [];
+  documents.forEach(doc => {
+    doc.definitions.forEach(definition => definitions.push(definition));
+  });
+  return definitions;
+}
+
+/**
+ * Extends a GraphQLSchema with a list of schema extensions in string form.
+ */
+function transformASTSchema(
+  schema: GraphQLSchema,
+  schemaExtensions: $ReadOnlyArray<string>,
+): GraphQLSchema {
+  return Profiler.run('ASTConvert.transformASTSchema', () => {
+    if (schemaExtensions.length === 0) {
+      return schema;
+    }
+    const extension = schemaExtensions.join('\n');
+    return cachedExtend(schema, extension, () =>
+      extendSchema(schema, parse(extension)),
+    );
+  });
+}
+
+/**
+ * Extends a GraphQLSchema with a list of schema extensions in AST form.
+ */
+function extendASTSchema(
+  baseSchema: GraphQLSchema,
+  documents: $ReadOnlyArray<DocumentNode>,
+): GraphQLSchema {
+  return Profiler.run('ASTConvert.extendASTSchema', () => {
+    const schemaExtensions: Array<
+      TypeSystemDefinitionNode | TypeSystemExtensionNode,
+    > = [];
+    documents.forEach(doc => {
+      doc.definitions.forEach(definition => {
+        if (isSchemaDefinitionAST(definition)) {
+          schemaExtensions.push(definition);
+        }
+      });
+    });
+    if (schemaExtensions.length === 0) {
+      return baseSchema;
+    }
+    const key = schemaExtensions.map(print).join('\n');
+    return cachedExtend(baseSchema, key, () =>
+      extendSchema(
+        baseSchema,
+        {
+          kind: 'Document',
+          definitions: schemaExtensions,
+        },
+        // TODO T24511737 figure out if this is dangerous
+        {assumeValid: true},
+      ),
+    );
+  });
+}
+
+const extendedSchemas: Map<
+  GraphQLSchema,
+  {[key: string]: GraphQLSchema, ...},
+> = new Map();
+
+function cachedExtend(
+  schema: GraphQLSchema,
+  key: string,
+  compute: () => GraphQLSchema,
+): GraphQLSchema {
+  let cache = extendedSchemas.get(schema);
+  if (!cache) {
+    cache = {};
+    extendedSchemas.set(schema, cache);
+  }
+  let extendedSchema = cache[key];
+  if (!extendedSchema) {
+    extendedSchema = compute();
+    cache[key] = extendedSchema;
+  }
+  return extendedSchema;
+}
+
+module.exports = {
+  convertASTDocuments,
+  convertASTDocumentsWithBase,
+  extendASTSchema,
+  transformASTSchema,
+};