@atlassian/webresource-webpack-plugin 4.10.2-64a2ef2

package/RELEASE.md

@@ -0,0 +1,17 @@
+# Release
+
+The only supported release branch in this repo is `release/4.x` which is only maintained for legacy purposes. All the new development should be done in https://bitbucket.org/atlassianlabs/fe-server/src/master/packages/webresource-webpack-plugin/
+
+## Stable release
+
+1. After merging to `release/4.x`, navigate to the [Bamboo](https://ecosystem-bamboo.internal.atlassian.com/browse/WRWP-WRWPB4X).
+2. Run `Release` stage to create a new stable release.
+3. Override `release.version` variable to set the version
+4. New release will be available on [npmjs](https://www.npmjs.com/package/atlassian-webresource-webpack-plugin?activeTab=versions) with `stable-4` tag.
+
+## Hash release
+
+1. Navigate to the Bamboo pipeline running on your feature branch
+2. Run `Release` stage to create a new hash release
+3. Override `release.version` variable to set the version
+4. Override `release.versionSuffix` variable to set the suffix (defaults to last commit hash)

package/package.json

@@ -0,0 +1,118 @@
+{
+  "name": "@atlassian/webresource-webpack-plugin",
+  "version": "4.10.2-64a2ef2",
+  "description": "Auto-generates web-resource definitions from your webpacked code, for usage in an Atlassian product or plugin.",
+  "main": "src/WrmPlugin.js",
+  "license": "Apache-2.0",
+  "contributors": [
+    {
+      "name": "Tim Sebastian",
+      "email": "tsebastian@atlassian.com"
+    },
+    {
+      "name": "Felipe Reis",
+      "email": "freis@atlassian.com"
+    },
+    {
+      "name": "Scott Harwood",
+      "email": "sharwood@atlassian.com"
+    },
+    {
+      "name": "Christopher Darroch",
+      "email": "cdarroch@atlassian.com"
+    },
+    {
+      "name": "Maciej Adamczak",
+      "email": "madamczak@atlassian.com"
+    },
+    {
+      "name": "Felipe Reis",
+      "email": "freis@atlassian.com"
+    },
+    {
+      "name": "Dariusz Luksza",
+      "email": "dluksza@adaptavist.com"
+    },
+    {
+      "name": "Dick Wiggers",
+      "email": "hwiggers@atlassian.com"
+    },
+    {
+      "name": "Matthieu Di Berardino",
+      "email": "mdiberardino@atlassian.com"
+    },
+    {
+      "name": "Pietro Pereira",
+      "email": "ppereira@atlassian.com"
+    }
+  ],
+  "homepage": "https://bitbucket.org/atlassianlabs/atlassian-webresource-webpack-plugin",
+  "repository": {
+    "type": "git",
+    "url": "https://bitbucket.org/atlassianlabs/atlassian-webresource-webpack-plugin.git"
+  },
+  "bugs": {
+    "url": "https://bitbucket.org/atlassianlabs/atlassian-webresource-webpack-plugin/issues"
+  },
+  "dependencies": {
+    "glob": "^7.1.2",
+    "lodash": "^4.17.15",
+    "mkdirp": "^0.5.1",
+    "pretty-data": "^0.40.0",
+    "tapable": "^1.1.0",
+    "url-join": "^4.0.0",
+    "uuid": "^3.3.2",
+    "webpack-merge": "^4.2.2",
+    "webpack-sources": "^1.1.0"
+  },
+  "devDependencies": {
+    "babel-eslint": "^10.0.1",
+    "chai": "^4.2.0",
+    "chai-string": "^1.5.0",
+    "chai-uuid": "^1.0.6",
+    "css-loader": "^1.0.1",
+    "eslint": "^5.9.0",
+    "eslint-config-prettier": "^3.3.0",
+    "eslint-plugin-babel": "^5.2.1",
+    "eslint-plugin-filenames": "^1.3.2",
+    "eslint-plugin-jasmine": "^2.10.1",
+    "eslint-plugin-mocha": "^5.2.0",
+    "eslint-plugin-node": "^8.0.0",
+    "eslint-plugin-prettier": "^3.0.0",
+    "extract-text-webpack-plugin": "4.0.0-beta.0",
+    "file-loader": "^2.0.0",
+    "jquery": "^3.4.1",
+    "mini-css-extract-plugin": "^0.4.4",
+    "mocha": "^5.2.0",
+    "mocha-junit-reporter": "^1.18.0",
+    "prettier": "^1.15.2",
+    "prettier-eslint": "^8.8.2",
+    "style-loader": "^0.23.1",
+    "underscore": "^1.9.1",
+    "webpack": "^4.41.3",
+    "webpack-cli": "^3.1.2",
+    "xml-parser": "^1.2.1"
+  },
+  "peerDependencies": {
+    "webpack": "^4"
+  },
+  "engines": {
+    "node": ">=8.12.0",
+    "npm": ">=6.9.0"
+  },
+  "keywords": [
+    "atlassian",
+    "webpack",
+    "wrm",
+    "server",
+    "web",
+    "webresource",
+    "resource",
+    "manager"
+  ],
+  "scripts": {
+    "lint": "eslint .",
+    "lint:fix": "eslint . --fix",
+    "test": "mocha 'test/**/*.test.js'"
+  }
+}

package/src/AppResources.js

@@ -0,0 +1,198 @@
+const {
+    getConditionForEntry,
+    getDataProvidersForEntry,
+    getContextForEntry,
+    getWebresourceAttributesForEntry,
+} = require('./helpers/web-resource-entrypoints');
+const flattenReduce = require('./flattenReduce');
+const WebpackHelpers = require('./WebpackHelpers');
+const { getBaseDependencies } = require('./settings/base-dependencies');
+
+const RUNTIME_WR_KEY = 'common-runtime';
+
+module.exports = class AppResources {
+    constructor(assetsUUID, assetNames, options, compiler, compilation) {
+        this.assetsUUID = assetsUUID;
+        this.assetNames = assetNames;
+        this.options = options;
+        this.compiler = compiler;
+        this.compilation = compilation;
+    }
+
+    isSingleRuntime() {
+        const options = this.compiler.options;
+        const runtimeChunkCfg = options.optimization && options.optimization.runtimeChunk;
+        return runtimeChunkCfg && runtimeChunkCfg.name && typeof runtimeChunkCfg.name === 'string';
+    }
+
+    getSingleRuntimeFiles(entrypoints) {
+        return Array.from(entrypoints.values())
+            .map(entrypoint => entrypoint.runtimeChunk.files)
+            .find(Boolean);
+    }
+
+    getAssetResourceDescriptor() {
+        const assetFiles = Object.keys(this.compilation.assets).filter(p => !/\.(js|css|soy)(\.map)?$/.test(p)); // remove anything that we know is handled differently
+
+        const assets = {
+            attributes: { key: `assets-${this.assetsUUID}` },
+            resources: assetFiles,
+        };
+
+        return assets;
+    }
+
+    /**
+     * Every entrypoint has an attribute called "chunks".
+     * This contains all chunks that are needed to successfully "load" this entrypoint.
+     * Usually every entrypoint only contains one chunk - the bundle that is build for that entrypoint.
+     * If more than one chunk is present that means they are split-chunks that contain code needed by the entrypoint to function.
+     * To get all split chunks we need to get all but the entrypoints "runtimeChunk" which is the chunk solely containing code for this entrypoint and its runtime.
+     *
+     * IMPORTANT-NOTE: async-chunks required by this entrypoint are not specified in these chunks but in the childGroups of the entry and/or split chunks.
+     */
+    getSyncSplitChunks() {
+        const entryPoints = [...this.compilation.entrypoints.values()];
+        const syncSplitChunks = entryPoints.map(e => e.chunks.filter(c => c !== e.runtimeChunk));
+
+        return Array.from(new Set(syncSplitChunks.reduce(flattenReduce, [])));
+    }
+
+    /**
+     * Create a key and the fully-qualified web-resource descriptor for every split chunk.
+     * This is needed to point to reference these chunks as dependency in the entrypoint chunks
+     *
+     * <web-resource>
+     *   ...
+     *   <dependency>this-plugin-key:split_some_chunk</dependency>
+     *   ...
+     */
+    getSyncSplitChunkDependenciesKeyMap(pluginKey, syncSplitChunks) {
+        const syncSplitChunkDependencyKeyMap = new Map();
+        for (const c of syncSplitChunks) {
+            const chunkIdentifier = WebpackHelpers.getChunkIdentifier(c);
+            const webResourceKey = `split_${chunkIdentifier}`;
+            syncSplitChunkDependencyKeyMap.set(chunkIdentifier, {
+                key: webResourceKey,
+                dependency: `${pluginKey}:${webResourceKey}`,
+            });
+        }
+
+        return syncSplitChunkDependencyKeyMap;
+    }
+
+    getSyncSplitChunksResourceDescriptors() {
+        const resourceToAssetMap = this.assetNames;
+
+        const syncSplitChunks = this.getSyncSplitChunks();
+        const syncSplitChunkDependencyKeyMap = this.getSyncSplitChunkDependenciesKeyMap(
+            this.options.pluginKey,
+            syncSplitChunks
+        );
+
+        /**
+         * Create descriptors for the split chunk web-resources that have to be created.
+         * These include - like other chunk-descriptors their assets and external resources etc.
+         */
+        const sharedSplitDescriptors = syncSplitChunks.map(c => {
+            const additionalFileDeps = WebpackHelpers.getDependencyResourcesFromChunk(c, resourceToAssetMap);
+            return {
+                attributes: syncSplitChunkDependencyKeyMap.get(WebpackHelpers.getChunkIdentifier(c)),
+                externalResources: WebpackHelpers.getExternalResourcesForChunk(c),
+                resources: Array.from(new Set(c.files.concat(additionalFileDeps))),
+                dependencies: getBaseDependencies().concat(WebpackHelpers.getDependenciesForChunks([c])),
+            };
+        });
+
+        return sharedSplitDescriptors;
+    }
+
+    getAsyncChunksResourceDescriptors() {
+        const entryPoints = [...this.compilation.entrypoints.values()];
+        const resourceToAssetMap = this.assetNames;
+
+        const asyncChunkDescriptors = WebpackHelpers.getAllAsyncChunks(entryPoints).map(c => {
+            const additionalFileDeps = WebpackHelpers.getDependencyResourcesFromChunk(c, resourceToAssetMap);
+            return {
+                attributes: { key: `${c.id}` },
+                externalResources: WebpackHelpers.getExternalResourcesForChunk(c),
+                resources: Array.from(new Set(c.files.concat(additionalFileDeps))),
+                dependencies: getBaseDependencies().concat(WebpackHelpers.getDependenciesForChunks([c])),
+                contexts: this.options.addAsyncNameAsContext && c.name ? [`async-chunk-${c.name}`] : undefined,
+            };
+        });
+
+        return asyncChunkDescriptors;
+    }
+
+    getEntryPointsResourceDescriptors() {
+        const entrypoints = this.compilation.entrypoints;
+        const resourceToAssetMap = this.assetNames;
+
+        const syncSplitChunks = this.getSyncSplitChunks();
+        const syncSplitChunkDependencyKeyMap = this.getSyncSplitChunkDependenciesKeyMap(
+            this.options.pluginKey,
+            syncSplitChunks
+        );
+
+        const singleRuntimeWebResourceKey = this.options.singleRuntimeWebResourceKey || RUNTIME_WR_KEY;
+
+        // Used in prod
+        const prodEntryPoints = [...entrypoints].map(([name, entrypoint]) => {
+            const webResourceAttrs = getWebresourceAttributesForEntry(name, this.options.webresourceKeyMap);
+            const entrypointChunks = entrypoint.chunks;
+            const runtimeChunk = entrypoint.runtimeChunk;
+
+            // Retrieve all split chunks this entrypoint depends on. These must be added as "<dependency>"s to the web-resource of this entrypoint
+            const sharedSplitDeps = entrypointChunks
+                .map(c => syncSplitChunkDependencyKeyMap.get(WebpackHelpers.getChunkIdentifier(c)))
+                .filter(Boolean)
+                .map(val => val.dependency);
+
+            const additionalFileDeps = entrypointChunks.map(c =>
+                WebpackHelpers.getDependencyResourcesFromChunk(c, resourceToAssetMap)
+            );
+            // Construct the list of resources to add to this web-resource
+            const resourceList = [].concat(...additionalFileDeps);
+            const dependencyList = [].concat(
+                getBaseDependencies(),
+                WebpackHelpers.getDependenciesForChunks([runtimeChunk]),
+                sharedSplitDeps
+            );
+
+            if (this.isSingleRuntime()) {
+                dependencyList.unshift(`${this.options.pluginKey}:${singleRuntimeWebResourceKey}`);
+            } else {
+                resourceList.unshift(...runtimeChunk.files);
+            }
+
+            return {
+                attributes: webResourceAttrs,
+                contexts: getContextForEntry(name, this.options.contextMap, this.options.addEntrypointNameAsContext),
+                conditions: getConditionForEntry(name, this.options.conditionMap),
+                dataProviders: getDataProvidersForEntry(name, this.options.dataProvidersMap),
+                externalResources: WebpackHelpers.getExternalResourcesForChunk(runtimeChunk),
+                resources: Array.from(new Set(resourceList)),
+                dependencies: Array.from(new Set(dependencyList)),
+            };
+        });
+
+        if (this.isSingleRuntime()) {
+            prodEntryPoints.push({
+                attributes: { key: singleRuntimeWebResourceKey },
+                dependencies: getBaseDependencies(),
+                resources: this.getSingleRuntimeFiles(entrypoints),
+            });
+        }
+
+        return prodEntryPoints;
+    }
+
+    getResourceDescriptors() {
+        return []
+            .concat(this.getSyncSplitChunksResourceDescriptors())
+            .concat(this.getAsyncChunksResourceDescriptors())
+            .concat(this.getEntryPointsResourceDescriptors())
+            .concat(this.getAssetResourceDescriptor());
+    }
+};

package/src/QUnitTestResources.js

@@ -0,0 +1,88 @@
+const glob = require('glob');
+const path = require('path');
+
+const { extractPathPrefixForXml } = require('./helpers/options-parser');
+const { getWebresourceAttributesForEntry } = require('./helpers/web-resource-entrypoints');
+const logger = require('./logger');
+const qUnitRequireMock = require('./shims/qunit-require-shim');
+const WebpackHelpers = require('./WebpackHelpers');
+
+const RESOURCE_JOINER = '__RESOURCE__JOINER__';
+module.exports = class QUnitTestResources {
+    constructor(assetsUUID, options, compiler, compilation) {
+        this.options = options;
+        this.compiler = compiler;
+        this.compilation = compilation;
+        this.qunitRequireMockPath = `qunit-require-shim-${assetsUUID}.js`;
+    }
+
+    createAllFileTestWebResources() {
+        return [...this.compilation.entrypoints.entries()].map(([name, entryPoint]) => {
+            const webResourceAttrs = getWebresourceAttributesForEntry(name, this.options.webresourceKeyMap);
+            const allEntryPointChunks = [...entryPoint.chunks, ...WebpackHelpers.getAllAsyncChunks([entryPoint])];
+
+            const testFiles = Array.from(
+                WebpackHelpers.extractAllFilesFromChunks(
+                    allEntryPointChunks,
+                    this.compiler.options.context,
+                    RESOURCE_JOINER
+                )
+            )
+                .map(resource => {
+                    if (resource.includes(RESOURCE_JOINER)) {
+                        return resource.split(RESOURCE_JOINER);
+                    }
+                    return [resource, resource];
+                })
+                .map(resourcePair => {
+                    return { name: resourcePair[0], location: resourcePair[1] };
+                });
+
+            // require mock to allow imports like "wr-dependency!context"
+            const pathPrefix = extractPathPrefixForXml('');
+            testFiles.unshift({
+                name: `${pathPrefix}${this.qunitRequireMockPath}`,
+                location: `${pathPrefix}${this.qunitRequireMockPath}`,
+            });
+
+            const testDependencies = Array.from(WebpackHelpers.getDependenciesForChunks(allEntryPointChunks));
+            return {
+                attributes: { key: `__test__${webResourceAttrs.key}`, name: webResourceAttrs.name },
+                externalResources: testFiles,
+                dependencies: testDependencies,
+            };
+        });
+    }
+
+    injectQUnitShim() {
+        this.compilation.assets[this.qunitRequireMockPath] = {
+            source: () => new Buffer(qUnitRequireMock),
+            size: () => Buffer.byteLength(qUnitRequireMock),
+        };
+    }
+
+    getTestFiles() {
+        const context = this.compiler.options.context;
+        const testGlobs = this.options.__testGlobs__;
+
+        if (!testGlobs) {
+            return [];
+        }
+
+        logger.warn(`
+******************************************************************************
+The option "__testGlobs__" is only available to allow migrating old code. Consider
+this option deprecated and try to migrate your code to a proper JS-Testrunner.
+******************************************************************************
+`);
+        return testGlobs
+            .map(g => glob.sync(g, { absolute: true })) // get all matching files
+            .reduce((_, _v, _i, files) => {
+                // flatten them and make them unique
+                const uniqueFiles = new Set([].concat(...files));
+                files.length = 0; // prevent further iteration ??MAGNETS??
+                return Array.from(uniqueFiles);
+            })
+            .map(file => path.relative(context, file)); // make them relative to the context
+    }
+};

package/src/WebpackHelpers.js

@@ -0,0 +1,176 @@
+const path = require('path');
+
+const ProvidedExternalDependencyModule = require('./webpack-modules/ProvidedExternalDependencyModule');
+const WrmDependencyModule = require('./webpack-modules/WrmDependencyModule');
+const WrmResourceModule = require('./webpack-modules/WrmResourceModule');
+
+const logger = require('./logger');
+const flattenReduce = require('./flattenReduce');
+
+module.exports = class WebpackHelpers {
+    static getAllAsyncChunks(entryPoints) {
+        const seenChunkGroups = new Set();
+        const recursivelyGetAllAsyncChunks = chunkGroups => {
+            if (!chunkGroups.length === 0) {
+                return [];
+            }
+
+            return chunkGroups
+                .filter(cg => {
+                    // circuit breaker
+                    // dont use a chunk group more than once
+                    const alreadySeen = seenChunkGroups.has(cg);
+                    seenChunkGroups.add(cg);
+                    return !alreadySeen;
+                })
+                .map(cg => [...cg.chunks, ...recursivelyGetAllAsyncChunks(cg.getChildren())])
+                .reduce(flattenReduce, []);
+        };
+
+        // get all async chunks "deep"
+        const allAsyncChunks = entryPoints
+            .map(e => recursivelyGetAllAsyncChunks(e.getChildren()))
+            .reduce(flattenReduce, []);
+
+        // dedupe
+        return Array.from(new Set(allAsyncChunks));
+    }
+
+    static _getExternalResourceModules(chunk) {
+        return chunk
+            .getModules()
+            .filter(m => m instanceof WrmResourceModule)
+            .map(m => m.getResource());
+    }
+
+    static getExternalResourcesForChunk(chunk) {
+        const externalResources = new Set();
+
+        for (const dep of WebpackHelpers._getExternalResourceModules(chunk)) {
+            externalResources.add(dep);
+        }
+        return Array.from(externalResources);
+    }
+
+    static _getExternalDependencyModules(chunk) {
+        return chunk
+            .getModules()
+            .filter(m => {
+                return m instanceof ProvidedExternalDependencyModule || m instanceof WrmDependencyModule;
+            })
+            .sort((a, b) => a.index - b.index)
+            .map(m => m.getDependency());
+    }
+
+    static getDependenciesForChunks(chunks) {
+        const externalDeps = new Set();
+        for (const chunk of chunks) {
+            for (const dep of WebpackHelpers._getExternalDependencyModules(chunk)) {
+                externalDeps.add(dep);
+            }
+            // TODO: figure out how to pass this "properly" as a module
+            if (chunk.needsWrmRequire) {
+                externalDeps.add('com.atlassian.plugins.atlassian-plugins-webresource-rest:web-resource-manager');
+            }
+        }
+        return Array.from(externalDeps);
+    }
+
+    static extractAdditionalAssetsFromChunk(chunk) {
+        const ownDeps = chunk.getModules().map(m => m.resource);
+        const ownDepsSet = new Set(ownDeps);
+        const fileDeps = chunk
+            .getModules()
+            .filter(m => m.buildInfo.fileDependencies)
+            .map(m => [...m.buildInfo.fileDependencies])
+            .reduce(flattenReduce, []);
+        const fileDepsSet = new Set(fileDeps);
+        return Array.from(fileDepsSet).filter(
+            filename => !ownDepsSet.has(filename) && !/\.(js|css|soy)(\.map)?$/.test(filename)
+        );
+    }
+
+    static getDependencyResourcesFromChunk(chunk, resourceToAssetMap) {
+        const deps = WebpackHelpers.extractAdditionalAssetsFromChunk(chunk);
+        return deps.filter(dep => resourceToAssetMap.has(dep)).map(dep => resourceToAssetMap.get(dep));
+    }
+
+    // get all files used in a chunk
+    // this is needed to create a web-resource that can be used by qunit tests.
+    // this is a "sledgehammer approach" to avoid having to create an entry point per qunit tests and building it via webpack.
+    static extractAllFilesFromChunks(chunks, context, RESOURCE_JOINER) {
+        const circularDepCheck = new Set();
+        const addModule = (mod, container) => {
+            if (circularDepCheck.has(mod)) {
+                logger.warn(`
+*********************************************************************************
+Circular dependency detected.
+The module ${mod.userRequest}/${mod.resource} is involved in a circular dependency.
+This might be worth looking into as it could be an issue.
+*********************************************************************************
+
+`);
+                return;
+            }
+            circularDepCheck.add(mod);
+
+            mod.dependencies
+                .map(d => d.module || d.originModule)
+                .filter(Boolean)
+                .filter(m => {
+                    // filter out all "virtual" modules that do not reference an actual file (or a wrm web-resource)
+                    if (m.resource) {
+                        return true;
+                    }
+                    if (m instanceof WrmResourceModule) {
+                        return true;
+                    }
+                    return false;
+                })
+
+                .filter(actualModule => !actualModule.resource || !actualModule.resource.includes('node_modules')) // if it references a file remove it if it comes from "node_modules"
+                .forEach(localModule => addModule(localModule, container)); // recursively add modules own dependencies first
+
+            if (mod.resource && !mod.resource.includes('node_modules')) {
+                const reference = path.relative(context, mod.resource);
+                container.add(reference);
+            }
+
+            // handle imports of resources through "wr-resource!..."-syntax
+            if (mod instanceof WrmResourceModule) {
+                container.add(mod.getResourcePair().join(RESOURCE_JOINER));
+            }
+        };
+
+        let dependencyTreeSet = new Set();
+        for (const chunk of chunks) {
+            for (const mod of chunk.getModules()) {
+                addModule(mod, dependencyTreeSet);
+            }
+        }
+        return dependencyTreeSet;
+    }
+
+    static getChunkIdentifier(chunk) {
+        return chunk.name || chunk.id;
+    }
+
+    /**
+     * Checks if webpack compiler is running in production mode
+     *
+     * @param   {Object}    compiler    Webpack compiler
+     * @returns {Boolean}               Returns true if webpack is running in production mode, false otherwise
+     */
+    static isRunningInProductionMode(compiler) {
+        const { options } = compiler;
+
+        if (options.mode) {
+            if (options.mode === 'production') {
+                return true;
+            } else if (options.mode === 'none') {
+                return process.env.NODE_ENV === 'production';
+            }
+        }
+        return false;
+    }
+};

package/src/WebpackRuntimeHelpers.js

@@ -0,0 +1,7 @@
+module.exports = class WebpackRuntimeHelpers {
+    static hookIntoNormalModuleFactory(compiler, cb) {
+        compiler.hooks.compile.tap('RuntimeHelper Compiler', params => {
+            params.normalModuleFactory.hooks.factory.tap('RuntimeHelper NormalModuleFactory', cb);
+        });
+    }
+};