Add empty query detection and skipping

Adds EmptyChecker to detect queries with no server-fetchable fields due to
@skip/@include directives or client-only fields. When enabled via the
ENABLE_EMPTY_QUERY_CHECK feature flag, empty queries are skipped and do not
result in network requests.

Key changes:
- New EmptyChecker module to traverse query AST and detect empty queries
- Add isEmpty() method to IEnvironment, IMultiActorEnvironment interfaces
- Skip execution in RelayModernEnvironment.execute() and executeWithSource()
- Update loadQuery to check isEmpty() before fetching
- Add 'execute.skipped' log event with reason: 'empty'
- Add comprehensive tests for EmptyChecker and React hooks integration
- Feature flag ENABLE_EMPTY_QUERY_CHECK (default: false)

Test plan:
- EmptyChecker-test.js: Tests all query AST node types and conditional logic
- useLazyLoadQueryNode-empty-query-test.js: Tests useLazyLoadQuery and
  usePreloadedQuery + loadQuery patterns with empty queries

Author: captbaritone

packages/react-relay/relay-hooks/__tests__/__generated__/useLazyLoadQueryNodeEmptyQueryTestPreloadedQuery.graphql.js

@@ -0,0 +1,149 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @flow
+ * @format
+ * @oncall relay
+ */
+
+'use strict';
+
+import type {LogEvent} from '../../../relay-runtime/store/RelayStoreTypes';
+
+const RelayEnvironmentProvider = require('../RelayEnvironmentProvider');
+const useLazyLoadQuery = require('../useLazyLoadQuery');
+const usePreloadedQuery = require('../usePreloadedQuery');
+const React = require('react');
+const ReactTestRenderer = require('react-test-renderer');
+const {
+  Environment,
+  Network,
+  RecordSource,
+  Store,
+  graphql,
+} = require('relay-runtime');
+const {loadQuery} = require('../loadQuery');
+const RelayFeatureFlags = require('relay-runtime/util/RelayFeatureFlags');
+
+const {disallowConsoleErrors, disallowWarnings} = jest.requireActual(
+  'relay-test-utils-internal',
+) as $FlowFixMe;
+
+disallowWarnings();
+disallowConsoleErrors();
+
+describe('useLazyLoadQuery with empty query', () => {
+  let environment;
+  let logs: Array<LogEvent>;
+  let renderFn;
+  let originalFlagValue;
+
+  beforeEach(() => {
+    originalFlagValue = RelayFeatureFlags.ENABLE_EMPTY_QUERY_CHECK;
+    RelayFeatureFlags.ENABLE_EMPTY_QUERY_CHECK = true;
+
+    logs = [];
+    environment = new Environment({
+      network: Network.create(() => {
+        throw new Error('Network should not be called for empty queries');
+      }),
+      store: new Store(new RecordSource(), {gcReleaseBufferSize: 0}),
+      log: event => {
+        logs.push(event);
+      },
+    });
+  });
+
+  afterEach(() => {
+    RelayFeatureFlags.ENABLE_EMPTY_QUERY_CHECK = originalFlagValue;
+  });
+
+  it('does not suspend when query is empty due to @skip', () => {
+    const query = graphql`
+      query useLazyLoadQueryNodeEmptyQueryTestSkipQuery($skip: Boolean!) {
+        me @skip(if: $skip) {
+          id
+          name
+        }
+      }
+    `;
+
+    function Renderer() {
+      const data = useLazyLoadQuery(
+        query,
+        {skip: true},
+        {fetchPolicy: 'network-only'},
+      );
+      return `Data: ${JSON.stringify(data)}`;
+    }
+
+    let instance;
+    ReactTestRenderer.act(() => {
+      instance = ReactTestRenderer.create(
+        <RelayEnvironmentProvider environment={environment}>
+          <React.Suspense fallback="Loading...">{<Renderer />}</React.Suspense>
+        </RelayEnvironmentProvider>,
+      );
+    });
+
+    // Should not suspend - render should complete immediately
+    expect(instance?.toJSON()).toEqual('Data: {}');
+
+    // Should have logged the empty query skip
+    expect(logs).toContainEqual(
+      expect.objectContaining({
+        name: 'execute.skipped',
+        reason: 'empty',
+      }),
+    );
+  });
+
+  it('does not make network request when using usePreloadedQuery with empty query', () => {
+    const query = graphql`
+      query useLazyLoadQueryNodeEmptyQueryTestPreloadedQuery($skip: Boolean!) {
+        me @skip(if: $skip) {
+          id
+          name
+        }
+      }
+    `;
+
+    const preloadedQuery = loadQuery(
+      environment,
+      query,
+      {skip: true},
+      {fetchPolicy: 'network-only'},
+    );
+
+    function Renderer() {
+      const data = usePreloadedQuery(query, preloadedQuery);
+      return `Data: ${JSON.stringify(data)}`;
+    }
+
+    let instance;
+    ReactTestRenderer.act(() => {
+      instance = ReactTestRenderer.create(
+        <RelayEnvironmentProvider environment={environment}>
+          <React.Suspense fallback="Loading...">{<Renderer />}</React.Suspense>
+        </RelayEnvironmentProvider>,
+      );
+    });
+
+    // Should not suspend - render should complete immediately
+    expect(instance?.toJSON()).toEqual('Data: {}');
+
+    // Should have logged the empty query skip
+    expect(logs).toContainEqual(
+      expect.objectContaining({
+        name: 'execute.skipped',
+        reason: 'empty',
+      }),
+    );
+
+    // Dispose the preloaded query
+    preloadedQuery.dispose();
+  });
+});