@pnpm/releasing.exportable-manifest 1100.3.1 → 1100.3.3

package/CHANGELOG.md

@@ -1,5 +1,29 @@
 # @pnpm/exportable-manifest
 
+## 1100.3.3
+
+### Patch Changes
+
+- The `publish` command now resolves `workspace:` dependencies from workspace manifests when `node_modules` is not installed. Previously, publishing without `node_modules` failed with `ERR_PNPM_CANNOT_RESOLVE_WORKSPACE_PROTOCOL`. pnpm/pnpm#6567
+
+- `make-dedicated-lockfile` no longer removes fields such as `main` and `types` from the `publishConfig` of the project's `package.json`.
+
+- `pnpm publish` and `pnpm pack` now report a missing `version` or `name` field on a workspace dependency. Previously, pnpm reported that the dependency was not installed [#4164](https://github.com/pnpm/pnpm/issues/4164).
+
+- Updated dependencies:
+  - @pnpm/bins.resolver@1100.0.17
+  - @pnpm/error@1100.2.0
+  - @pnpm/resolving.jsr-specifier-parser@1100.0.8
+  - @pnpm/types@1102.1.1
+  - @pnpm/workspace.project-manifest-reader@1100.1.0
+
+## 1100.3.2
+
+### Patch Changes
+
+- Updated dependencies:
+  - @pnpm/workspace.project-manifest-reader@1100.0.29
+
 ## 1100.3.1
 
 ### Patch Changes

package/lib/index.d.ts

@@ -3,12 +3,17 @@ import type { Hooks } from '@pnpm/hooks.pnpmfile';
 import type { ProjectManifest } from '@pnpm/types';
 import { type ExportedManifest } from './transform/index.js';
 export { type ExportedManifest };
+export type WorkspacePackageLookup = Array<{
+    manifest: ProjectManifest;
+    rootDir?: string;
+}> | Map<string, unknown> | Record<string, unknown> | ((depName: string) => ProjectManifest | undefined);
 export interface MakePublishManifestOptions {
     catalogs: Catalogs;
     hooks?: Hooks;
     modulesDir?: string;
     skipManifestObfuscation?: boolean;
     embedReadme?: boolean;
+    workspacePackages?: WorkspacePackageLookup;
 }
 export declare function createExportableManifest(dir: string, originalManifest: ProjectManifest, opts: MakePublishManifestOptions): Promise<ExportedManifest>;
 export declare function readReadmeFile(projectDir: string): Promise<string | undefined>;
@@ -16,8 +21,10 @@ export type PublishDependencyConverter = (depName: string, depSpec: string, cont
 export interface PublishDependencyConverterContext {
     dir: string;
     modulesDir?: string;
+    workspacePackages?: (depName: string) => ProjectManifest | undefined;
 }
 export interface MakePublishDependenciesOpts {
     readonly modulesDir?: string;
     readonly convertDependencyForPublish: PublishDependencyConverter;
+    readonly workspacePackages?: (depName: string) => ProjectManifest | undefined;
 }

package/lib/index.js

@@ -31,11 +31,13 @@ export async function createExportableManifest(dir, originalManifest, opts) {
     }
     const catalogResolver = resolveFromCatalog.bind(null, opts.catalogs);
     const replaceCatalogProtocol = resolveCatalogProtocol.bind(null, catalogResolver);
+    const getWorkspaceManifest = buildWorkspaceManifestGetter(opts.workspacePackages);
     const convertDependencyForPublish = combineConverters(replaceCatalogProtocol, replaceWorkspaceProtocol, replaceJsrProtocol);
     await Promise.all(['dependencies', 'devDependencies', 'optionalDependencies'].map(async (depsField) => {
         const deps = await makePublishDependencies(dir, originalManifest[depsField], {
             modulesDir: opts?.modulesDir,
             convertDependencyForPublish,
+            workspacePackages: getWorkspaceManifest,
         });
         if (deps != null) {
             publishManifest[depsField] = deps;
@@ -47,6 +49,7 @@ export async function createExportableManifest(dir, originalManifest, opts) {
         publishManifest.peerDependencies = await makePublishDependencies(dir, peerDependencies, {
             modulesDir: opts?.modulesDir,
             convertDependencyForPublish: convertPeersForPublish,
+            workspacePackages: getWorkspaceManifest,
         });
     }
     overridePublishConfig(publishManifest);
@@ -99,19 +102,91 @@ function combineConverters(...converters) {
         return bareSpecifier;
     };
 }
-async function makePublishDependencies(dir, dependencies, { modulesDir, convertDependencyForPublish }) {
+async function makePublishDependencies(dir, dependencies, { modulesDir, convertDependencyForPublish, workspacePackages }) {
     if (dependencies == null)
         return dependencies;
-    const publishDependencies = await Promise.all(Object.entries(dependencies).map(async ([depName, depSpec]) => [depName, await convertDependencyForPublish(depName, depSpec, { dir, modulesDir })]));
+    const publishDependencies = await Promise.all(Object.entries(dependencies).map(async ([depName, depSpec]) => [depName, await convertDependencyForPublish(depName, depSpec, { dir, modulesDir, workspacePackages })]));
     return Object.fromEntries(publishDependencies);
 }
-async function readAndCheckManifest(depName, dependencyDir) {
-    const { manifest } = await tryReadProjectManifest(dependencyDir);
-    if (!manifest?.name || !manifest?.version) {
+function extractManifest(val) {
+    if (!val || typeof val !== 'object')
+        return undefined;
+    if ('manifest' in val && val.manifest && typeof val.manifest === 'object') {
+        return val.manifest;
+    }
+    if ('package' in val && val.package && typeof val.package === 'object' && 'manifest' in val.package && val.package.manifest && typeof val.package.manifest === 'object') {
+        return val.package.manifest;
+    }
+    if ('name' in val && typeof val.name === 'string') {
+        return val;
+    }
+    return undefined;
+}
+function buildWorkspaceManifestGetter(workspacePackages) {
+    if (!workspacePackages)
+        return undefined;
+    if (typeof workspacePackages === 'function') {
+        return workspacePackages;
+    }
+    const byName = new Map();
+    const addManifest = (val) => {
+        const manifest = extractManifest(val);
+        if (!manifest?.name)
+            return;
+        const existing = byName.get(manifest.name);
+        if (!existing || (!existing.version && manifest.version)) {
+            byName.set(manifest.name, manifest);
+        }
+    };
+    if (Array.isArray(workspacePackages)) {
+        for (const pkg of workspacePackages) {
+            addManifest(pkg);
+        }
+    }
+    else if (workspacePackages instanceof Map) {
+        for (const val of workspacePackages.values()) {
+            if (val instanceof Map) {
+                for (const subVal of val.values()) {
+                    addManifest(subVal);
+                }
+            }
+            else {
+                addManifest(val);
+            }
+        }
+    }
+    else if (typeof workspacePackages === 'object') {
+        for (const val of Object.values(workspacePackages)) {
+            addManifest(val);
+        }
+    }
+    return (depName) => byName.get(depName);
+}
+async function readAndCheckManifest(depName, dependencyDir, getWorkspaceManifest, targetPkgName) {
+    const { manifest: dirManifest } = await tryReadProjectManifest(dependencyDir);
+    if (dirManifest?.name && dirManifest?.version) {
+        return dirManifest;
+    }
+    const lookupName = targetPkgName ?? depName;
+    const workspaceManifest = getWorkspaceManifest?.(lookupName);
+    if (workspaceManifest?.name && workspaceManifest?.version) {
+        return workspaceManifest;
+    }
+    const found = dirManifest?.name || dirManifest?.version
+        ? dirManifest
+        : workspaceManifest?.name || workspaceManifest?.version
+            ? workspaceManifest
+            : dirManifest ?? workspaceManifest;
+    if (found?.name && !found.version) {
+        throw new PnpmError('CANNOT_RESOLVE_WORKSPACE_PROTOCOL', `Cannot resolve workspace protocol of dependency "${depName}" ` +
+            'because its package.json has no "version" field.', { hint: `Add a "version" field to the package.json of "${found.name}".` });
+    }
+    if (found) {
         throw new PnpmError('CANNOT_RESOLVE_WORKSPACE_PROTOCOL', `Cannot resolve workspace protocol of dependency "${depName}" ` +
-            'because this dependency is not installed. Try running "pnpm install".');
+            'because its package.json has no "name" field.');
     }
-    return manifest;
+    throw new PnpmError('CANNOT_RESOLVE_WORKSPACE_PROTOCOL', `Cannot resolve workspace protocol of dependency "${depName}" ` +
+        'because this dependency is not installed. Try running "pnpm install".');
 }
 function resolveCatalogProtocol(catalogResolver, alias, bareSpecifier) {
     const result = catalogResolver({ alias, bareSpecifier });
@@ -121,7 +196,7 @@ function resolveCatalogProtocol(catalogResolver, alias, bareSpecifier) {
         case 'misconfiguration': throw result.error;
     }
 }
-async function replaceWorkspaceProtocol(depName, depSpec, { dir, modulesDir }) {
+async function replaceWorkspaceProtocol(depName, depSpec, { dir, modulesDir, workspacePackages }) {
     if (!depSpec.startsWith('workspace:')) {
         return depSpec;
     }
@@ -129,7 +204,8 @@ async function replaceWorkspaceProtocol(depName, depSpec, { dir, modulesDir }) {
     const versionAliasSpecParts = /^workspace:(?:(.+)@)?([\^~*])?$/.exec(depSpec);
     if (versionAliasSpecParts != null) {
         modulesDir = modulesDir ?? path.join(dir, 'node_modules');
-        const manifest = await readAndCheckManifest(depName, path.join(modulesDir, depName));
+        const targetPkgName = versionAliasSpecParts[1];
+        const manifest = await readAndCheckManifest(depName, path.join(modulesDir, depName), workspacePackages, targetPkgName);
         const specifierSuffix = versionAliasSpecParts[2];
         const semverRangeToken = specifierSuffix === '^' || specifierSuffix === '~' ? specifierSuffix : '';
         if (depName !== manifest.name) {
@@ -138,7 +214,7 @@ async function replaceWorkspaceProtocol(depName, depSpec, { dir, modulesDir }) {
         return `${semverRangeToken}${manifest.version}`;
     }
     if (depSpec.startsWith('workspace:./') || depSpec.startsWith('workspace:../')) {
-        const manifest = await readAndCheckManifest(depName, path.join(dir, depSpec.slice(10)));
+        const manifest = await readAndCheckManifest(depName, path.join(dir, depSpec.slice(10)), workspacePackages);
         if (manifest.name === depName)
             return `${manifest.version}`;
         return `npm:${manifest.name}@${manifest.version}`;
@@ -149,7 +225,7 @@ async function replaceWorkspaceProtocol(depName, depSpec, { dir, modulesDir }) {
     }
     return depSpec;
 }
-async function replaceWorkspaceProtocolPeerDependency(depName, depSpec, { dir, modulesDir }) {
+async function replaceWorkspaceProtocolPeerDependency(depName, depSpec, { dir, modulesDir, workspacePackages }) {
     if (!depSpec.includes('workspace:')) {
         return depSpec;
     }
@@ -161,7 +237,7 @@ async function replaceWorkspaceProtocolPeerDependency(depName, depSpec, { dir, m
         return `npm:${workspaceSpec.alias}@${version}`;
     }
     if (workspaceSpec?.version.startsWith('./') || workspaceSpec?.version.startsWith('../')) {
-        return replaceWorkspaceProtocol(depName, depSpec, { dir, modulesDir });
+        return replaceWorkspaceProtocol(depName, depSpec, { dir, modulesDir, workspacePackages });
     }
     // Dependencies with bare "*", "^", "~",">=",">","<=", "<", version
     const workspaceSemverRegex = /workspace:([\^~*]|>=|>|<=|<)?((\d+|[xX*])(\.(\d+|[xX*])){0,2})?/;
@@ -172,7 +248,7 @@ async function replaceWorkspaceProtocolPeerDependency(depName, depSpec, { dir, m
             return depSpec.replace('workspace:', '');
         }
         modulesDir = modulesDir ?? path.join(dir, 'node_modules');
-        const manifest = await readAndCheckManifest(depName, path.join(modulesDir, depName));
+        const manifest = await readAndCheckManifest(depName, path.join(modulesDir, depName), workspacePackages);
         const semverRangeToken = semverRangGroup !== '*' ? semverRangGroup : '';
         return depSpec.replace(workspaceSemverRegex, `${semverRangeToken}${manifest.version}`);
     }

package/lib/overridePublishConfig.js

@@ -30,9 +30,9 @@ const PUBLISH_CONFIG_WHITELIST = new Set([
     'typesVersions',
 ]);
 export function overridePublishConfig(publishManifest) {
-    const { publishConfig } = publishManifest;
-    if (!publishConfig)
+    if (!publishManifest.publishConfig)
         return;
+    const publishConfig = { ...publishManifest.publishConfig };
     for (const key in publishConfig) {
         if (!PUBLISH_CONFIG_WHITELIST.has(key))
             continue;
@@ -43,5 +43,8 @@ export function overridePublishConfig(publishManifest) {
     if (isEmpty(publishConfig)) {
         delete publishManifest.publishConfig;
     }
+    else {
+        publishManifest.publishConfig = publishConfig;
+    }
 }
 //# sourceMappingURL=overridePublishConfig.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pnpm/releasing.exportable-manifest",
-  "version": "1100.3.1",
+  "version": "1100.3.3",
   "description": "Creates an exportable manifest",
   "keywords": [
     "pnpm",
@@ -28,22 +28,22 @@
   ],
   "dependencies": {
     "@npm/types": "^2.1.0",
-    "@pnpm/bins.resolver": "1100.0.16",
+    "@pnpm/bins.resolver": "1100.0.17",
     "@pnpm/catalogs.resolver": "1100.1.0",
-    "@pnpm/error": "1100.1.4",
-    "@pnpm/resolving.jsr-specifier-parser": "1100.0.7",
-    "@pnpm/types": "1102.1.0",
-    "@pnpm/workspace.project-manifest-reader": "1100.0.28",
+    "@pnpm/error": "1100.2.0",
+    "@pnpm/resolving.jsr-specifier-parser": "1100.0.8",
+    "@pnpm/types": "1102.1.1",
+    "@pnpm/workspace.project-manifest-reader": "1100.1.0",
     "@pnpm/workspace.spec-parser": "1100.0.1",
     "ramda": "npm:@pnpm/ramda@0.28.1"
   },
   "devDependencies": {
     "@jest/globals": "30.4.1",
-    "@pnpm/catalogs.config": "1100.0.7",
+    "@pnpm/catalogs.config": "1100.0.8",
     "@pnpm/catalogs.types": "1100.0.1",
-    "@pnpm/hooks.pnpmfile": "1100.0.31",
-    "@pnpm/prepare": "1100.0.30",
-    "@pnpm/releasing.exportable-manifest": "1100.3.1",
+    "@pnpm/hooks.pnpmfile": "1100.0.33",
+    "@pnpm/prepare": "1100.0.32",
+    "@pnpm/releasing.exportable-manifest": "1100.3.3",
     "@types/cross-spawn": "^6.0.6",
     "@types/ramda": "0.32.0",
     "cross-spawn": "^7.0.6",