Add caching of process.env.NODE_ENV, for performance reasons

src/cache/inmemory/readFromStore.ts

@@ -27,6 +27,7 @@ import {
   maybeDeepFreeze,
   mergeDeepArray,
 } from '../../utilities';
+import { isProduction } from '../../utilities/common/environment';
 import { Cache } from '../core/types/Cache';
 import {
   DiffQueryAgainstStoreOptions,
@@ -288,7 +289,7 @@ export class StoreReader {
           // as a scalar value. However, that value should not contain any
           // Reference objects, and should be frozen in development, if it
           // happens to be an object that is mutable.
-          if (process.env.NODE_ENV !== 'production') {
+          if (!isProduction()) {
             assertSelectionSetForIdValue(
               context.store,
               selection,
@@ -337,7 +338,7 @@ export class StoreReader {
     // defensive shallow copies than necessary.
     finalResult.result = mergeDeepArray(objectsToMerge);
 
-    if (process.env.NODE_ENV !== 'production') {
+    if (!isProduction()) {
       Object.freeze(finalResult.result);
     }
 
@@ -414,7 +415,7 @@ export class StoreReader {
         }), i);
       }
 
-      if (process.env.NODE_ENV !== 'production') {
+      if (!isProduction()) {
         assertSelectionSetForIdValue(context.store, field, item);
       }
 
@@ -423,7 +424,7 @@ export class StoreReader {
       return item;
     });
 
-    if (process.env.NODE_ENV !== 'production') {
+    if (!isProduction()) {
       Object.freeze(array);
     }
 

src/cache/inmemory/writeToStore.ts

@@ -21,6 +21,7 @@ import {
   hasDirectives,
   cloneDeep,
 } from '../../utilities';
+import { isProduction } from '../../utilities/common/environment';
 
 import { NormalizedCache, ReadMergeModifyContext } from './types';
 import { makeProcessedFieldsMerger, FieldValueToBeMerged, fieldNameFromStoreName } from './helpers';
@@ -259,7 +260,7 @@ export class StoreWriter {
         mergedFields = policies.applyMerges(entityRef, mergedFields, context);
       }
 
-      if (process.env.NODE_ENV !== "production") {
+      if (!isProduction()) {
         Object.keys(mergedFields).forEach(storeFieldName => {
           const fieldName = fieldNameFromStoreName(storeFieldName);
           // If a merge function was defined for this field, trust that it
@@ -293,7 +294,7 @@ export class StoreWriter {
       // In development, we need to clone scalar values so that they can be
       // safely frozen with maybeDeepFreeze in readFromStore.ts. In production,
       // it's cheaper to store the scalar values directly in the cache.
-      return process.env.NODE_ENV === 'production' ? value : cloneDeep(value);
+      return isProduction() ? value : cloneDeep(value);
     }
 
     if (Array.isArray(value)) {

src/core/ApolloClient.ts

@@ -4,6 +4,7 @@ import { invariant, InvariantError } from 'ts-invariant';
 import { ApolloLink, FetchResult, GraphQLRequest, execute } from '../link/core';
 import { ApolloCache, DataProxy } from '../cache';
 import { Observable, compact } from '../utilities';
+import { isProduction } from '../utilities/common/environment';
 import { version } from '../version';
 import { HttpLink, UriFunction } from '../link/http';
 
@@ -171,7 +172,7 @@ export class ApolloClient<TCacheShape> implements DataProxy {
     // Attach the client instance to window to let us be found by chrome devtools, but only in
     // development mode
     const defaultConnectToDevTools =
-      process.env.NODE_ENV !== 'production' &&
+      !isProduction() &&
       typeof window !== 'undefined' &&
       !(window as any).__APOLLO_CLIENT__;
 
@@ -186,7 +187,7 @@ export class ApolloClient<TCacheShape> implements DataProxy {
     /**
      * Suggest installing the devtools for developers who don't have them
      */
-    if (!hasSuggestedDevtools && process.env.NODE_ENV !== 'production') {
+    if (!hasSuggestedDevtools && !isProduction()) {
       hasSuggestedDevtools = true;
       if (
         typeof window !== 'undefined' &&

src/core/ObservableQuery.ts

@@ -19,6 +19,7 @@ import {
   FetchMoreQueryOptions,
   SubscribeToMoreOptions,
 } from './watchQueryOptions';
+import { isProduction } from '../utilities/common/environment';
 import { Reobserver } from './Reobserver';
 import { QueryInfo } from './QueryInfo';
 
@@ -312,7 +313,7 @@ export class ObservableQuery<
       const { updateQuery } = fetchMoreOptions;
 
       if (updateQuery) {
-        if (process.env.NODE_ENV !== "production" &&
+        if (!isProduction() &&
             !warnedAboutUpdateQuery) {
           invariant.warn(
 `The updateQuery callback for fetchMore is deprecated, and will be removed

src/core/QueryManager.ts

@@ -20,6 +20,7 @@ import {
   Concast,
   ConcastSourcesIterable,
 } from '../utilities';
+import { isProduction } from '../utilities/common/environment';
 import { ApolloError, isApolloError } from '../errors';
 import { MutationStore } from './MutationStore';
 import {
@@ -961,7 +962,7 @@ export class QueryManager<TStore> {
     ) => {
       const data = diff.result as TData;
 
-      if (process.env.NODE_ENV !== 'production' &&
+      if (!isProduction() &&
           isNonEmptyArray(diff.missing) &&
           !equal(data, {})) {
         invariant.warn(`Missing cache result fields: ${

src/utilities/common/__tests__/environment.ts

@@ -1,4 +1,9 @@
-import { isEnv, isDevelopment, isTest } from '../environment';
+import { refreshEnv, isEnv, isDevelopment, isTest } from '../environment';
+
+function setNodeEnv(env: string|undefined) {
+  process.env.NODE_ENV = env;
+  refreshEnv();
+}
 
 describe('environment', () => {
   let keepEnv: string | undefined;
@@ -10,48 +15,50 @@ describe('environment', () => {
 
   afterEach(() => {
     // restore the NODE_ENV
-    process.env.NODE_ENV = keepEnv;
+    setNodeEnv(keepEnv);
   });
 
   describe('isEnv', () => {
     it(`should match when there's a value`, () => {
       ['production', 'development', 'test'].forEach(env => {
-        process.env.NODE_ENV = env;
+        setNodeEnv(env);
         expect(isEnv(env)).toBe(true);
       });
     });
 
-    it(`should treat no proces.env.NODE_ENV as it'd be in development`, () => {
+    it(`should treat no process.env.NODE_ENV as it'd be in development`, () => {
       delete process.env.NODE_ENV;
+      refreshEnv();
       expect(isEnv('development')).toBe(true);
     });
   });
 
   describe('isTest', () => {
     it('should return true if in test', () => {
-      process.env.NODE_ENV = 'test';
+      setNodeEnv('test');
       expect(isTest()).toBe(true);
     });
 
     it('should return true if not in test', () => {
-      process.env.NODE_ENV = 'development';
+      setNodeEnv('development');
       expect(!isTest()).toBe(true);
     });
   });
 
   describe('isDevelopment', () => {
     it('should return true if in development', () => {
-      process.env.NODE_ENV = 'development';
+      setNodeEnv('development');
       expect(isDevelopment()).toBe(true);
     });
 
     it('should return true if not in development and environment is defined', () => {
-      process.env.NODE_ENV = 'test';
+      setNodeEnv('test');
       expect(!isDevelopment()).toBe(true);
     });
 
     it('should make development as the default environment', () => {
       delete process.env.NODE_ENV;
+      refreshEnv();
       expect(isDevelopment()).toBe(true);
     });
   });

src/utilities/common/environment.ts

@@ -1,20 +1,36 @@
-export function getEnv(): string | undefined {
+// Functions for checking whether we're in a development, production, or test
+// environment. Uses the NODE_ENV environment variable as the source of truth.
+// This is cached on startup, because process.env is actually a C function and
+// calling it is somewhat expensive (enough to show up prominently in profiler
+// results, if not cached.)
+
+let node_env: string = "development";
+
+export function refreshEnv(): void {
   if (typeof process !== 'undefined' && process.env.NODE_ENV) {
-    return process.env.NODE_ENV;
+    node_env = process.env.NODE_ENV;
+  } else {
+    node_env = "development";
   }
+}
+refreshEnv();
 
-  // default environment
-  return 'development';
+export function getEnv(): string | undefined {
+  return node_env;
 }
 
 export function isEnv(env: string): boolean {
   return getEnv() === env;
 }
 
 export function isDevelopment(): boolean {
-  return isEnv('development') === true;
+  return node_env==='development';
+}
+
+export function isProduction(): boolean {
+  return node_env==='production';
 }
 
 export function isTest(): boolean {
-  return isEnv('test') === true;
+  return node_env==='test';
 }

src/utilities/common/maybeDeepFreeze.ts

@@ -1,4 +1,4 @@
-import { isDevelopment, isTest } from './environment';
+import { isDevelopment, isProduction, isTest } from './environment';
 
 function isObject(value: any) {
   return value !== null && typeof value === "object";
@@ -18,7 +18,7 @@ function deepFreeze(value: any) {
 }
 
 export function maybeDeepFreeze<T>(obj: T): T {
-  if (process.env.NODE_ENV !== "production" && (isDevelopment() || isTest())) {
+  if (!isProduction() && (isDevelopment() || isTest())) {
     deepFreeze(obj);
   }
   return obj;