@atlaspack/reporter-conditional-manifest 2.14.1 → 2.14.2

package/CHANGELOG.md

@@ -1,5 +1,15 @@
 # @atlaspack/reporter-conditional-manifest
 
+## 2.14.2
+
+### Patch Changes
+
+- [#494](https://github.com/atlassian-labs/atlaspack/pull/494) [`9b85d3e`](https://github.com/atlassian-labs/atlaspack/commit/9b85d3e645b10bd027eed2304afc970a5ba40062) Thanks [@JakeLane](https://github.com/JakeLane)! - When conditionalBundlingReporterDuplicateFix is enabled, avoid duplicated writes to the descriptor and logging
+
+- Updated dependencies [[`9b85d3e`](https://github.com/atlassian-labs/atlaspack/commit/9b85d3e645b10bd027eed2304afc970a5ba40062), [`17b9579`](https://github.com/atlassian-labs/atlaspack/commit/17b9579484eced0ed8f23e2aba6d23b3c7238c39), [`8f4e6c1`](https://github.com/atlassian-labs/atlaspack/commit/8f4e6c1b0e7c1fd48624afda48c1dcc599f1460f)]:
+  - @atlaspack/feature-flags@2.14.2
+  - @atlaspack/plugin@2.14.2
+
 ## 2.14.1
 
 ### Patch Changes

package/lib/ConditionalManifestReporter.js

@@ -3,7 +3,9 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.default = void 0;
+exports.manifestHashes = exports.default = void 0;
+exports.report = report;
+exports.updateManifest = void 0;
 function _path() {
   const data = require("path");
   _path = function () {
@@ -11,6 +13,13 @@ function _path() {
   };
   return data;
 }
+function _crypto() {
+  const data = _interopRequireDefault(require("crypto"));
+  _crypto = function () {
+    return data;
+  };
+  return data;
+}
 function _plugin() {
   const data = require("@atlaspack/plugin");
   _plugin = function () {
@@ -19,6 +28,29 @@ function _plugin() {
   return data;
 }
 var _Config = require("./Config");
+function _featureFlags() {
+  const data = require("@atlaspack/feature-flags");
+  _featureFlags = function () {
+    return data;
+  };
+  return data;
+}
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+const manifestHashes = exports.manifestHashes = new Map();
+const updateManifest = async (outputFS, logger, conditionalManifestFilename, conditionalManifest) => {
+  const hash = _crypto().default.createHash('sha1').update(conditionalManifest).digest('hex');
+  if (manifestHashes.get(conditionalManifestFilename) !== hash) {
+    manifestHashes.set(conditionalManifestFilename, hash);
+    await outputFS.mkdirp((0, _path().dirname)(conditionalManifestFilename));
+    await outputFS.writeFile(conditionalManifestFilename, conditionalManifest, {
+      mode: 0o666
+    });
+    logger.info({
+      message: `Wrote conditional manifest to ${conditionalManifestFilename}`
+    });
+  }
+};
+exports.updateManifest = updateManifest;
 async function report({
   event,
   options,
@@ -52,13 +84,17 @@ async function report({
       const conditionalManifest = JSON.stringify(
       // If there's no content, send an empty manifest so we can still map from it safely
       manifest[target.name] ?? {}, null, 2);
-      await options.outputFS.mkdirp((0, _path().dirname)(conditionalManifestFilename));
-      await options.outputFS.writeFile(conditionalManifestFilename, conditionalManifest, {
-        mode: 0o666
-      });
-      logger.info({
-        message: 'Wrote conditional manifest to ' + conditionalManifestFilename
-      });
+      if ((0, _featureFlags().getFeatureFlag)('conditionalBundlingReporterDuplicateFix')) {
+        await updateManifest(options.outputFS, logger, conditionalManifestFilename, conditionalManifest);
+      } else {
+        await options.outputFS.mkdirp((0, _path().dirname)(conditionalManifestFilename));
+        await options.outputFS.writeFile(conditionalManifestFilename, conditionalManifest, {
+          mode: 0o666
+        });
+        logger.info({
+          message: 'Wrote conditional manifest to ' + conditionalManifestFilename
+        });
+      }
     }
   }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@atlaspack/reporter-conditional-manifest",
-  "version": "2.14.1",
+  "version": "2.14.2",
   "license": "MIT",
   "publishConfig": {
     "access": "public"
@@ -15,7 +15,8 @@
     "node": ">= 16.0.0"
   },
   "dependencies": {
-    "@atlaspack/plugin": "2.14.1",
+    "@atlaspack/plugin": "2.14.2",
+    "@atlaspack/feature-flags": "2.14.2",
     "nullthrows": "^1.1.1"
   },
   "type": "commonjs"

package/src/ConditionalManifestReporter.js

@@ -1,5 +1,6 @@
 // @flow strict-local
 import {relative, join, dirname} from 'path';
+import crypto from 'crypto';
 import {Reporter} from '@atlaspack/plugin';
 import type {
   Async,
@@ -7,10 +8,40 @@ import type {
   PluginOptions,
   PluginTracer,
   ReporterEvent,
+  FileSystem,
+  FilePath,
 } from '@atlaspack/types-internal';
 import {getConfig} from './Config';
+import {getFeatureFlag} from '@atlaspack/feature-flags';
 
-async function report({
+export const manifestHashes: Map<FilePath, string> = new Map();
+
+export const updateManifest = async (
+  outputFS: FileSystem,
+  logger: PluginLogger,
+  conditionalManifestFilename: FilePath,
+  conditionalManifest: string,
+) => {
+  const hash = crypto
+    .createHash('sha1')
+    .update(conditionalManifest)
+    .digest('hex');
+
+  if (manifestHashes.get(conditionalManifestFilename) !== hash) {
+    manifestHashes.set(conditionalManifestFilename, hash);
+
+    await outputFS.mkdirp(dirname(conditionalManifestFilename));
+    await outputFS.writeFile(conditionalManifestFilename, conditionalManifest, {
+      mode: 0o666,
+    });
+
+    logger.info({
+      message: `Wrote conditional manifest to ${conditionalManifestFilename}`,
+    });
+  }
+};
+
+export async function report({
   event,
   options,
   logger,
@@ -59,17 +90,26 @@ async function report({
         2,
       );
 
-      await options.outputFS.mkdirp(dirname(conditionalManifestFilename));
+      if (getFeatureFlag('conditionalBundlingReporterDuplicateFix')) {
+        await updateManifest(
+          options.outputFS,
+          logger,
+          conditionalManifestFilename,
+          conditionalManifest,
+        );
+      } else {
+        await options.outputFS.mkdirp(dirname(conditionalManifestFilename));
+        await options.outputFS.writeFile(
+          conditionalManifestFilename,
+          conditionalManifest,
+          {mode: 0o666},
+        );
 
-      await options.outputFS.writeFile(
-        conditionalManifestFilename,
-        conditionalManifest,
-        {mode: 0o666},
-      );
-
-      logger.info({
-        message: 'Wrote conditional manifest to ' + conditionalManifestFilename,
-      });
+        logger.info({
+          message:
+            'Wrote conditional manifest to ' + conditionalManifestFilename,
+        });
+      }
     }
   }
 }

package/test/ConditionalManifestReporter.test.js

@@ -0,0 +1,114 @@
+// @flow strict-local
+import {
+  manifestHashes,
+  updateManifest,
+} from '../src/ConditionalManifestReporter';
+import sinon from 'sinon';
+import assert from 'assert';
+
+let createMockOverlayFS = () => ({
+  // Mock filesystem methods
+  writeFile: sinon.stub(),
+  readFile: sinon.stub(),
+  exists: sinon.stub(),
+  chdir: sinon.stub(),
+  copyFile: sinon.stub(),
+  createReadStream: sinon.stub(),
+  createWriteStream: sinon.stub(),
+  cwd: sinon.stub(),
+  existsSync: sinon.stub(),
+  findAncestorFile: sinon.stub(),
+  findFirstFile: sinon.stub(),
+  findNodeModule: sinon.stub(),
+  getEventsSince: sinon.stub(),
+  mkdirp: sinon.stub(),
+  ncp: sinon.stub(),
+  readFileSync: sinon.stub(),
+  readdir: sinon.stub(),
+  readdirSync: sinon.stub(),
+  realpath: sinon.stub(),
+  realpathSync: sinon.stub(),
+  rimraf: sinon.stub(),
+  stat: sinon.stub(),
+  statSync: sinon.stub(),
+  symlink: sinon.stub(),
+  unlink: sinon.stub(),
+  watch: sinon.stub(),
+  writeSnapshot: sinon.stub(),
+});
+
+let createMockLogger = () => ({
+  // Mock logger methods
+  warn: sinon.stub(),
+  info: sinon.stub(),
+  verbose: sinon.stub(),
+  error: sinon.stub(),
+  log: sinon.stub(),
+});
+
+describe('ConditionalManifestReporter', function () {
+  beforeEach(() => {
+    manifestHashes.clear();
+  });
+
+  it('should write the manifest to file', async function () {
+    let logger = createMockLogger();
+    let overlayFS = createMockOverlayFS();
+
+    const conditionalManifestFilename =
+      '/project-root/dist/conditional-manifest.json';
+    const conditionalManifest = JSON.stringify({test: 'manifest'});
+
+    await updateManifest(
+      overlayFS,
+      logger,
+      conditionalManifestFilename,
+      conditionalManifest,
+    );
+
+    // Verify that writeFile was called with the correct arguments
+    assert(
+      overlayFS.writeFile.calledWith(
+        conditionalManifestFilename,
+        conditionalManifest,
+        {mode: 0o666},
+      ),
+    );
+
+    // Verify that logger.info was called with the correct message
+    assert(
+      logger.info.calledWith({
+        message: `Wrote conditional manifest to ${conditionalManifestFilename}`,
+      }),
+    );
+  });
+
+  it('should not write the manifest if it has not changed', async function () {
+    let logger = createMockLogger();
+    let overlayFS = createMockOverlayFS();
+
+    let conditionalManifestFilename =
+      '/project-root/dist/conditional-manifest.json';
+    let conditionalManifest = JSON.stringify({test: 'manifest'});
+
+    await updateManifest(
+      overlayFS,
+      logger,
+      conditionalManifestFilename,
+      conditionalManifest,
+    );
+
+    await updateManifest(
+      overlayFS,
+      logger,
+      conditionalManifestFilename,
+      conditionalManifest,
+    );
+
+    // Verify that writeFile was called once
+    assert(overlayFS.writeFile.calledOnce);
+
+    // Verify that logger.info was called with the correct message
+    assert(logger.info.calledOnce);
+  });
+});