feat: copy LICENSE file from monorepo root on pack

.yarn/versions/c2ad8ad7.yml

@@ -0,0 +1,24 @@
+releases:
+  "@yarnpkg/cli": minor
+  "@yarnpkg/plugin-pack": major
+
+declined:
+  - "@yarnpkg/plugin-compat"
+  - "@yarnpkg/plugin-constraints"
+  - "@yarnpkg/plugin-dlx"
+  - "@yarnpkg/plugin-essentials"
+  - "@yarnpkg/plugin-init"
+  - "@yarnpkg/plugin-interactive-tools"
+  - "@yarnpkg/plugin-nm"
+  - "@yarnpkg/plugin-npm"
+  - "@yarnpkg/plugin-npm-cli"
+  - "@yarnpkg/plugin-patch"
+  - "@yarnpkg/plugin-pnp"
+  - "@yarnpkg/plugin-pnpm"
+  - "@yarnpkg/plugin-stage"
+  - "@yarnpkg/plugin-typescript"
+  - "@yarnpkg/plugin-version"
+  - "@yarnpkg/plugin-workspace-tools"
+  - "@yarnpkg/builder"
+  - "@yarnpkg/core"
+  - "@yarnpkg/doctor"

packages/acceptance-tests/pkg-tests-specs/sources/commands/pack.test.js

@@ -2,14 +2,18 @@ import {xfs, npath}          from '@yarnpkg/fslib';
 import {fs as fsUtils, misc} from 'pkg-tests-core';
 import tar                   from 'tar';
 
-async function genPackList(run) {
-  const {stdout} = await run(`pack`, `--dry-run`, `--json`);
-
+function parseJsonStream(stdout) {
   return misc.parseJsonStream(stdout).map(entry => {
     return entry.location;
   }).filter(location => !!location);
 }
 
+async function genPackList(run) {
+  const {stdout} = await run(`pack`, `--dry-run`, `--json`);
+
+  return parseJsonStream(stdout);
+}
+
 describe(`Commands`, () => {
   describe(`pack`, () => {
     test(
@@ -890,5 +894,49 @@ describe(`Commands`, () => {
         expect(originalManifest.devDependencies[dependency]).toBe(`workspace:*`);
       }),
     );
+
+    test(
+      `pack packages with workspace root LICENSE if no own LICENSE is present`,
+      makeTemporaryMonorepoEnv({
+        name: `monorepo`,
+        private: true,
+        workspaces: [
+          `packages/*`,
+        ],
+      }, {
+        [`packages/foo`]: {
+          name: `foo`,
+          version: `1.0.0`,
+        },
+        [`packages/bar`]: {
+          name: `bar`,
+          version: `1.0.0`,
+        },
+      }, async ({path, run}) => {
+        await run(`install`);
+
+        await xfs.writeFilePromise(npath.toPortablePath(`${path}/LICENSE`), `# title\n`);
+        await xfs.writeFilePromise(npath.toPortablePath(`${path}/LICENSE.md`), `# title\n`);
+
+        const {stdout: fooStdout} = await run(`workspace`, `foo`, `pack`, `--dry-run`, `--json`);
+        const fooPackList = parseJsonStream(fooStdout);
+
+        expect(fooPackList).toEqual([
+          `package.json`,
+          `LICENSE`,
+          `LICENSE.md`,
+        ]);
+
+        await xfs.writeFilePromise(npath.toPortablePath(`${path}/packages/bar/LICENSE.txt`), `# title\n`);
+
+        const {stdout: barStdout} = await run(`workspace`, `bar`, `pack`, `--dry-run`, `--json`);
+        const barPackList = parseJsonStream(barStdout);
+
+        expect(barPackList).toEqual([
+          `LICENSE.txt`,
+          `package.json`,
+        ]);
+      }),
+    );
   });
 });

packages/plugin-npm-cli/sources/commands/npm/publish.ts

@@ -95,7 +95,7 @@ export default class NpmPublishCommand extends BaseCommand {
       await packUtils.prepareForPack(workspace, {report}, async () => {
         const files = await packUtils.genPackList(workspace);
 
-        for (const file of files)
+        for (const {file} of files)
           report.reportInfo(null, file);
 
         const pack = await packUtils.genPackStream(workspace, files);

packages/plugin-pack/sources/commands/pack.ts

@@ -83,7 +83,7 @@ export default class PackCommand extends BaseCommand {
 
         const files = await packUtils.genPackList(workspace);
 
-        for (const file of files) {
+        for (const {file} of files) {
           report.reportInfo(null, npath.fromPortablePath(file));
           report.reportJson({location: npath.fromPortablePath(file)});
         }

packages/plugin-pack/sources/packUtils.ts

@@ -7,6 +7,8 @@ import {createGzip}                                                           fr
 
 import {Hooks}                                                                from './';
 
+const LICENSE_PATTERN = /licen[cs]e(\.[a-zA-Z0-9]+)?/i;
+
 const NEVER_IGNORE = [
   `/package.json`,
 
@@ -67,9 +69,10 @@ export async function prepareForPack(workspace: Workspace, {report}: {report: Re
   }
 }
 
-export async function genPackStream(workspace: Workspace, files?: Array<PortablePath>) {
-  if (typeof files === `undefined`)
-    files = await genPackList(workspace);
+export async function genPackStream(workspace: Workspace, files?: Array<PortablePath | {file: PortablePath, source: PortablePath}>) {
+  const normalizedFiles = files?.map(file => typeof file === `string`
+    ? {file, source: ppath.resolve(workspace.cwd, file)}
+    : file) ?? await genPackList(workspace);
 
   const executableFiles = new Set<PortablePath>();
   for (const value of workspace.manifest.publishConfig?.executableFiles ?? new Set())
@@ -80,10 +83,9 @@ export async function genPackStream(workspace: Workspace, files?: Array<Portable
   const pack = tar.pack();
 
   process.nextTick(async () => {
-    for (const fileRequest of files!) {
+    for (const {file: fileRequest, source} of normalizedFiles!) {
       const file = ppath.normalize(fileRequest);
 
-      const source = ppath.resolve(workspace.cwd, file);
       const dest = ppath.join(`package`, file);
 
       const stat = await xfs.lstatPromise(source);
@@ -239,11 +241,34 @@ export async function genPackList(workspace: Workspace) {
     }
   }
 
-  return await walk(workspace.cwd, {
+  const paths = await walk(workspace.cwd, {
     hasExplicitFileList,
     globalList,
     ignoreList,
   });
+
+  const files = paths.map(path => ({file: path, source: ppath.resolve(workspace.cwd, path)}));
+
+  if (workspace.cwd !== project.cwd) {
+    const workspaceHasLicense = paths.some(path => path.match(LICENSE_PATTERN));
+
+    if (!workspaceHasLicense) {
+      const projectDir = await xfs.readdirPromise(project.cwd);
+
+      const licenses = await Promise.all(projectDir
+        .filter(path => path.match(LICENSE_PATTERN))
+        .map(async path => [path, await xfs.lstatPromise(ppath.join(project.cwd, path))] as const))
+        .then(result => result
+          .filter(([_, stat]) => stat.isFile())
+          .map(([file]) => file));
+
+      for (const file of licenses) {
+        files.push({file, source: ppath.join(project.cwd, file)});
+      }
+    }
+  }
+
+  return files;
 }
 
 async function walk(initialCwd: PortablePath, {hasExplicitFileList, globalList, ignoreList}: {hasExplicitFileList: boolean, globalList: IgnoreList, ignoreList: IgnoreList}) {