@atlaspack/feature-flags 2.12.1-dev.3398 → 2.12.1-dev.3443

package/lib/index.js

@@ -5,15 +5,20 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.DEFAULT_FEATURE_FLAGS = void 0;
 exports.getFeatureFlag = getFeatureFlag;
+exports.runWithConsistencyCheck = runWithConsistencyCheck;
 exports.setFeatureFlags = setFeatureFlags;
 // We need to do these gymnastics as we don't want flow-to-ts to touch DEFAULT_FEATURE_FLAGS,
 // but we want to export FeatureFlags for Flow
 const DEFAULT_FEATURE_FLAGS = exports.DEFAULT_FEATURE_FLAGS = {
+  exampleConsistencyCheckFeature: 'OLD',
   exampleFeature: false,
   atlaspackV3: false,
   useWatchmanWatcher: false,
   importRetry: false,
-  ownedResolverStructures: false
+  fixQuadraticCacheInvalidation: 'OLD',
+  fastOptimizeInlineRequires: false,
+  useLmdbJsLite: false,
+  conditionalBundlingApi: false
 };
 let featureFlagValues = {
   ...DEFAULT_FEATURE_FLAGS
@@ -22,5 +27,35 @@ function setFeatureFlags(flags) {
   featureFlagValues = flags;
 }
 function getFeatureFlag(flagName) {
-  return featureFlagValues[flagName];
+  const value = featureFlagValues[flagName];
+  return value === true || value === 'NEW';
+}
+/**
+ * Run a function with a consistency check.
+ */
+function runWithConsistencyCheck(flag, oldFn, newFn, diffFn, report) {
+  const value = featureFlagValues[flag];
+  if (!value || value === false || value === 'OLD') {
+    return oldFn();
+  }
+  if (value === true || value === 'NEW') {
+    return newFn();
+  }
+  const oldStartTime = performance.now();
+  const oldResult = oldFn();
+  const oldExecutionTimeMs = performance.now() - oldStartTime;
+  const newStartTime = performance.now();
+  const newResult = newFn();
+  const newExecutionTimeMs = performance.now() - newStartTime;
+  const diff = diffFn(oldResult, newResult);
+  report({
+    isDifferent: diff.isDifferent,
+    oldExecutionTimeMs,
+    newExecutionTimeMs,
+    custom: diff.custom
+  }, oldResult, newResult);
+  if (value === 'NEW_AND_CHECK') {
+    return newResult;
+  }
+  return oldResult;
 }

package/lib/types.d.ts

@@ -1,6 +1,7 @@
 export type FeatureFlags = {
   // This feature flag mostly exists to test the feature flag system, and doesn't have any build/runtime effect
   readonly exampleFeature: boolean;
+  readonly exampleConsistencyCheckFeature: ConsistencyCheckFeatureFlagValue;
 
   /**
    * Rust backed requests
@@ -18,7 +19,25 @@ export type FeatureFlags = {
   importRetry: boolean;
 
   /**
-   * Enable resolver refactor into owned data structures.
+   * Enable Rust based LMDB wrapper library
    */
-  ownedResolverStructures: boolean;
+  useLmdbJsLite: boolean;
+
+  /**
+   * Fixes quadratic cache invalidation issue
+   */
+  fixQuadraticCacheInvalidation: ConsistencyCheckFeatureFlagValue;
+
+  /**
+   * Enable rust based inline requires optimization
+   */
+  fastOptimizeInlineRequires: boolean;
+
+  /**
+   * Enables an experimental "conditional bundling" API - this allows the use of `importCond` syntax
+   * in order to have (consumer) feature flag driven bundling. This feature is very experimental,
+   * and requires server-side support.
+   */
+  conditionalBundlingApi: boolean;
 };
+export type ConsistencyCheckFeatureFlagValue = "NEW" | "OLD" | "NEW_AND_CHECK" | "OLD_AND_CHECK";

package/package.json

@@ -1,8 +1,8 @@
 {
   "name": "@atlaspack/feature-flags",
-  "version": "2.12.1-dev.3398+81c73b3cd",
+  "version": "2.12.1-dev.3443+d1170cfc7",
   "description": "Provides internal feature-flags for the atlaspack codebase.",
-  "license": "MIT",
+  "license": "(MIT OR Apache-2.0)",
   "publishConfig": {
     "access": "public"
   },
@@ -20,5 +20,5 @@
   "engines": {
     "node": ">= 16.0.0"
   },
-  "gitHead": "81c73b3cdf93adf8b0013be9fed5422579bd5910"
+  "gitHead": "d1170cfc79beb290b2a066f472f68f71f7d7cb23"
 }

package/src/index.js

@@ -6,11 +6,15 @@ import type {FeatureFlags as _FeatureFlags} from './types';
 export type FeatureFlags = _FeatureFlags;
 
 export const DEFAULT_FEATURE_FLAGS: FeatureFlags = {
+  exampleConsistencyCheckFeature: 'OLD',
   exampleFeature: false,
   atlaspackV3: false,
   useWatchmanWatcher: false,
   importRetry: false,
-  ownedResolverStructures: false,
+  fixQuadraticCacheInvalidation: 'OLD',
+  fastOptimizeInlineRequires: false,
+  useLmdbJsLite: false,
+  conditionalBundlingApi: false,
 };
 
 let featureFlagValues: FeatureFlags = {...DEFAULT_FEATURE_FLAGS};
@@ -20,5 +24,71 @@ export function setFeatureFlags(flags: FeatureFlags) {
 }
 
 export function getFeatureFlag(flagName: $Keys<FeatureFlags>): boolean {
-  return featureFlagValues[flagName];
+  const value = featureFlagValues[flagName];
+  return value === true || value === 'NEW';
+}
+
+export type DiffResult<CustomDiagnostic> = {|
+  isDifferent: boolean,
+  custom: CustomDiagnostic,
+|};
+
+export type Diagnostic<CustomDiagnostic> = {|
+  isDifferent: boolean,
+  oldExecutionTimeMs: number,
+  newExecutionTimeMs: number,
+  custom: CustomDiagnostic,
+|};
+
+/**
+ * Run a function with a consistency check.
+ */
+export function runWithConsistencyCheck<Result, CustomDiagnostic>(
+  flag: string,
+  oldFn: () => Result,
+  newFn: () => Result,
+  diffFn: (
+    oldResult: Result,
+    newResult: Result,
+  ) => DiffResult<CustomDiagnostic>,
+  report: (
+    diagnostic: Diagnostic<CustomDiagnostic>,
+    oldResult: Result,
+    newResult: Result,
+  ) => void,
+): Result {
+  const value = featureFlagValues[flag];
+  if (!value || value === false || value === 'OLD') {
+    return oldFn();
+  }
+  if (value === true || value === 'NEW') {
+    return newFn();
+  }
+
+  const oldStartTime = performance.now();
+  const oldResult = oldFn();
+  const oldExecutionTimeMs = performance.now() - oldStartTime;
+
+  const newStartTime = performance.now();
+  const newResult = newFn();
+  const newExecutionTimeMs = performance.now() - newStartTime;
+
+  const diff = diffFn(oldResult, newResult);
+
+  report(
+    {
+      isDifferent: diff.isDifferent,
+      oldExecutionTimeMs,
+      newExecutionTimeMs,
+      custom: diff.custom,
+    },
+    oldResult,
+    newResult,
+  );
+
+  if (value === 'NEW_AND_CHECK') {
+    return newResult;
+  }
+
+  return oldResult;
 }

package/src/types.js

@@ -3,6 +3,7 @@
 export type FeatureFlags = {|
   // This feature flag mostly exists to test the feature flag system, and doesn't have any build/runtime effect
   +exampleFeature: boolean,
+  +exampleConsistencyCheckFeature: ConsistencyCheckFeatureFlagValue,
   /**
    * Rust backed requests
    */
@@ -16,7 +17,27 @@ export type FeatureFlags = {|
    */
   importRetry: boolean,
   /**
-   * Enable resolver refactor into owned data structures.
+   * Enable Rust based LMDB wrapper library
    */
-  ownedResolverStructures: boolean,
+  useLmdbJsLite: boolean,
+  /**
+   * Fixes quadratic cache invalidation issue
+   */
+  fixQuadraticCacheInvalidation: ConsistencyCheckFeatureFlagValue,
+  /**
+   * Enable rust based inline requires optimization
+   */
+  fastOptimizeInlineRequires: boolean,
+  /**
+   * Enables an experimental "conditional bundling" API - this allows the use of `importCond` syntax
+   * in order to have (consumer) feature flag driven bundling. This feature is very experimental,
+   * and requires server-side support.
+   */
+  conditionalBundlingApi: boolean,
 |};
+
+export type ConsistencyCheckFeatureFlagValue =
+  | 'NEW'
+  | 'OLD'
+  | 'NEW_AND_CHECK'
+  | 'OLD_AND_CHECK';

package/test/feature-flags.test.js

@@ -1,6 +1,12 @@
 // @flow strict
 import assert from 'assert';
-import {getFeatureFlag, DEFAULT_FEATURE_FLAGS, setFeatureFlags} from '../src';
+import {
+  getFeatureFlag,
+  DEFAULT_FEATURE_FLAGS,
+  setFeatureFlags,
+  runWithConsistencyCheck,
+} from '../src';
+import sinon from 'sinon';
 
 describe('feature-flag test', () => {
   beforeEach(() => {
@@ -18,4 +24,82 @@ describe('feature-flag test', () => {
     setFeatureFlags({...DEFAULT_FEATURE_FLAGS, exampleFeature: true});
     assert.equal(getFeatureFlag('exampleFeature'), true);
   });
+
+  describe('consistency checks', () => {
+    it('runs the old function if the flag is off', () => {
+      setFeatureFlags({
+        ...DEFAULT_FEATURE_FLAGS,
+        exampleConsistencyCheckFeature: 'OLD',
+      });
+      const result = runWithConsistencyCheck(
+        'exampleConsistencyCheckFeature',
+        () => 'old',
+        () => 'new',
+        sinon.spy(),
+        sinon.spy(),
+      );
+      assert.equal(result, 'old');
+    });
+
+    it('runs the new function if the flag is on', () => {
+      setFeatureFlags({
+        ...DEFAULT_FEATURE_FLAGS,
+        exampleConsistencyCheckFeature: 'NEW',
+      });
+      const result = runWithConsistencyCheck(
+        'exampleConsistencyCheckFeature',
+        () => 'old',
+        () => 'new',
+        sinon.spy(),
+        sinon.spy(),
+      );
+      assert.equal(result, 'new');
+    });
+
+    it('diffs old and new values if there is a diff value', () => {
+      setFeatureFlags({
+        ...DEFAULT_FEATURE_FLAGS,
+        exampleConsistencyCheckFeature: 'OLD_AND_CHECK',
+      });
+      const reportSpy = sinon.spy();
+      const result = runWithConsistencyCheck(
+        'exampleConsistencyCheckFeature',
+        () => 'old',
+        () => 'new',
+        () => ({isDifferent: false, custom: 'diff'}),
+        reportSpy,
+      );
+
+      assert.equal(result, 'old');
+      sinon.assert.calledWith(reportSpy, {
+        isDifferent: false,
+        oldExecutionTimeMs: sinon.match.number,
+        newExecutionTimeMs: sinon.match.number,
+        custom: 'diff',
+      });
+    });
+
+    it('diffs old and new values if there is a diff new value', () => {
+      setFeatureFlags({
+        ...DEFAULT_FEATURE_FLAGS,
+        exampleConsistencyCheckFeature: 'NEW_AND_CHECK',
+      });
+      const reportSpy = sinon.spy();
+      const result = runWithConsistencyCheck(
+        'exampleConsistencyCheckFeature',
+        () => 'old',
+        () => 'new',
+        () => ({isDifferent: true, custom: 'diff'}),
+        reportSpy,
+      );
+
+      assert.equal(result, 'new');
+      sinon.assert.calledWith(reportSpy, {
+        isDifferent: true,
+        oldExecutionTimeMs: sinon.match.number,
+        newExecutionTimeMs: sinon.match.number,
+        custom: 'diff',
+      });
+    });
+  });
 });