Top 10 Examples of "relay-compiler in functional component" in JavaScript

function parseGraphQLText(
  schema: GraphQLSchema,
  text: string,
): {
  definitions: $ReadOnlyArray,
  schema: ?GraphQLSchema,
} {
  const ast = parse(text);
  // TODO T24511737 figure out if this is dangerous
  const extendedSchema = extendSchema(schema, ast, {assumeValid: true});
  const definitions = convertASTDocuments(
    extendedSchema,
    [ast],
    [],
    Parser.transform.bind(Parser),
  );
  return {
    definitions,
    schema: extendedSchema !== schema ? extendedSchema : null,
  };
}

getFileFilter: RelayJSModuleParser.getFileFilter,
      getParser: RelayJSModuleParser.getParser,
      getSchema: () => getSchema(schemaPath),
      watchmanExpression: useWatchman ? buildWatchExpression(options) : null,
      filepaths: useWatchman ? null : getFilepathsFromGlob(srcDir, options),
    },
  };
  const writerConfigs = {
    default: {
      getWriter: getRelayFileWriter(srcDir),
      isGeneratedFile: (filePath: string) =>
        filePath.endsWith('.js') && filePath.includes('__generated__'),
      parser: 'default',
    },
  };
  const codegenRunner = new CodegenRunner({
    reporter,
    parserConfigs,
    writerConfigs,
    onlyValidate: options.validate,
  });
  if (!options.validate && !options.watch) {
    // eslint-disable-next-line no-console
    console.log('HINT: pass --watch to keep watching for changes.');
  }
  const result = options.watch
    ? await codegenRunner.watchAll()
    : await codegenRunner.compileAll();

  if (result === 'ERROR') {
    process.exit(100);
  }

if (!config.withFragmentContainer) {
      return "";
    }
    let queryName = doc.name.split("_")[0];
    if (!queryName) {
      return "";
    }
    const query = queryDocuments.find(query => query.name === queryName);

    if (!query) {
      console.warn(
        `Fragment '${doc.name}' uses relay notation but no query was found.`
      );
      return "";
    }
    const queryAst = parse(GraphQLIRPrinter.print(query));

    // @TODO: there might be multiple selection paths that use this fragment
    // build path on generated type
    const selectionPath = [];
    let currentSelectionSet = null;

    visit(queryAst, {
      enter: (node, key, parent) => {
        if (node.kind === "SelectionSet") {
          currentSelectionSet = node;
          if (parent.kind === "OperationDefinition") {
            selectionPath.push({
              type: "query",
              name: parent.name.value
            });
          } else {

extensions: ['graphql'],
        include: ['**'],
        exclude: excludeGraphql,
      }),
    },
  };
  const writerConfigs = {
    js: {
      getWriter: getRelayFileWriter(srcDir, persistQuery),
      isGeneratedFile: (filePath: string) =>
        filePath.endsWith('.js') && filePath.includes('__generated__'),
      parser: 'js',
      baseParsers: ['graphql'],
    },
  };
  const codegenRunner = new CodegenRunner({
    reporter,
    parserConfigs,
    writerConfigs,
    onlyValidate: false,
    sourceControl: null,
  });

  let result = '';
  try {
    // the real work is done here
    result = await codegenRunner.compileAll();
  } catch (err) {
    console.log(`Error codegenRunner.compileAll(): ${err}`);
    throw err;
  }

extensions: ['graphql'],
        include: options.include,
        exclude: options.exclude,
      }),
    },
  };
  const writerConfigs = {
    js: {
      getWriter: getRelayFileWriter(srcDir, persistQuery),
      isGeneratedFile: (filePath: string) =>
        filePath.endsWith('.js') && filePath.includes('__generated__'),
      parser: 'js',
      baseParsers: ['graphql'],
    },
  };
  const codegenRunner = new CodegenRunner({
    reporter,
    parserConfigs,
    writerConfigs,
    onlyValidate: false,
    sourceControl: null,
  });

  let result = '';
  try {
    // the real work is done here
    result = await codegenRunner.compileAll();
  } catch (err) {
    console.log(`Error codegenRunner.compileAll(): ${err}`);
    throw err;
  }

ts.createTypeReferenceNode(responseType.name, undefined)
          ),
          objectTypeProperty(
            "variables",
            ts.createTypeReferenceNode(inputVariablesType.name, undefined)
          )
        ];

        // Generate raw response type
        let rawResponseType;
        const { normalizationIR } = options;
        if (
          normalizationIR &&
          node.directives.some(d => d.name === DIRECTIVE_NAME)
        ) {
          rawResponseType = IRVisitor.visit(
            normalizationIR,
            createRawResponseTypeVisitor(schema, state)
          );
        }
        const refetchableFragmentName = getRefetchableQueryParentFragmentName(
          state,
          node.metadata
        );
        if (state.hasConnectionResolver) {
          state.runtimeImports.add("ConnectionReference");
        }
        if (refetchableFragmentName !== null) {
          state.runtimeImports.add("FragmentReference");
        }
        const nodes = [];
        if (state.runtimeImports.size) {

const adjustedSchema = transformASTSchema(schema, [
    /* GraphQL */ `
      directive @connection(key: String!) on FIELD
      directive @client on FIELD
    `
  ]);
  const documentAsts = documents.reduce(
    (prev, v) => {
      return [...prev, ...v.content.definitions];
    },
    [] as DefinitionNode[]
  );

  const relayDocuments = RelayParser.transform(adjustedSchema, documentAsts);

  const fragmentCompilerContext = new GraphQLCompilerContext(
    adjustedSchema
  ).addAll(relayDocuments);

  const fragmentDocuments = fragmentCompilerContext
    .applyTransforms([
      RelayApplyFragmentArgumentTransform.transform,
      FlattenTransform.transformWithOptions({ flattenAbstractTypes: false }),
      SkipRedundantNodesTransform.transform
    ])
    .documents()
    .filter(doc => doc.kind === "Fragment");

  const queryCompilerContext = new GraphQLCompilerContext(adjustedSchema)
    .addAll(relayDocuments)
    .applyTransforms([
      RelayApplyFragmentArgumentTransform.transform,

transformRawExample(rawExample: SingleRawExample, schema: string): RelayExample {
    const schemaAst = graphql.buildASTSchema(graphql.parse(schema));
    let context = new graphqlCompiler.CompilerContext(schemaAst);
    // In some queries, we leverage Hermes' @static directive; but Relay doesn't
    // like unknown directives. Quick hack to remove it.
    const scrubbedOperation = rawExample.operation.replace(/@static/g, '');
    context = context.addAll(graphqlCompiler.Parser.parse(schemaAst, scrubbedOperation));
    const artifacts = relayCompiler.compileRelayArtifacts(context, TRANSFORMS) as any[];

    const requests = artifacts.filter(a => a.kind !== 'Fragment');
    if (requests.length !== 1) {
      throw new Error(`Expected the query document to contain only one operation`);
    }
    const request = relayRuntime.getRequest(requests[0]);
    const operation = relayRuntime.createOperationSelector(request, rawExample.variables);

    return {
      operation,
      response: rawExample.response,
    };
  }

}
			return cachedDir;
		};

		const transformedTSContext = compilerContext.applyTransforms(
			RelayTSGenerator.TS_TRANSFORMS,
			this._reporter,
		);
		const transformedQueryContext = compilerContext.applyTransforms(
			[
				...this._config.compilerTransforms.commonTransforms,
				...this._config.compilerTransforms.queryTransforms,
			],
			this._reporter,
		);
		const artifacts = compileRelayArtifacts(
			compilerContext,
			this._config.compilerTransforms,
			this._reporter,
		);

		const existingFragmentNames = new Set(
			definitions.map(definition => definition.name),
		);

		// TODO(T22651734): improve this to correctly account for fragments that
		// have generated flow types.
		baseDefinitionNames.forEach(baseDefinitionName => {
			existingFragmentNames.delete(baseDefinitionName);
		});

		const formatModule = this._config.formatModule;

export const plugin: PluginFunction = (
  schema: GraphQLSchema,
  documents: Types.DocumentFile[],
  // eslint-disable-next-line @typescript-eslint/no-unused-vars
  config: RelayOptimizerPluginConfig
) => {
  // @TODO way for users to define directives they use, otherwise relay will throw an unknown directive error
  // Maybe we can scan the queries and add them dynamically without users having to do some extra stuff
  // transformASTSchema creates a new schema instance instead of mutating the old one
  const adjustedSchema = RelayCreate.create(
    printSchemaWithDirectives(
      transformASTSchema(schema, [
        /* GraphQL */ `
          directive @connection(key: String!) on FIELD
          directive @client on FIELD
        `,
      ])
    )
  );
  const documentAsts = documents.reduce((prev, v) => {
    return [...prev, ...v.content.definitions];
  }, [] as DefinitionNode[]);

  const relayDocuments = RelayParser.transform(adjustedSchema, documentAsts);

  const fragmentCompilerContext = new GraphQLCompilerContext(adjustedSchema).addAll(relayDocuments);

  const fragmentDocuments = fragmentCompilerContext