@pnpm/releasing.commands 1100.5.5 → 1100.6.1

package/lib/deploy/deploy.js

@@ -1,393 +0,0 @@
-import fs from 'node:fs';
-import path from 'node:path';
-import { FILTERING } from '@pnpm/cli.common-cli-options-help';
-import { docsUrl } from '@pnpm/cli.utils';
-import { types as configTypes } from '@pnpm/config.reader';
-import { WORKSPACE_MANIFEST_FILENAME } from '@pnpm/constants';
-import { PnpmError } from '@pnpm/error';
-import { fetchFromDir } from '@pnpm/fetching.directory-fetcher';
-import { createIndexedPkgImporter } from '@pnpm/fs.indexed-pkg-importer';
-import { isEmptyDirOrNothing } from '@pnpm/fs.is-empty-dir-or-nothing';
-import { install } from '@pnpm/installing.commands';
-import { getLockfileImporterId, readWantedLockfile, writeWantedLockfile } from '@pnpm/lockfile.fs';
-import { globalWarn, logger } from '@pnpm/logger';
-import { rimraf } from '@zkochan/rimraf';
-import { isSubdir } from 'is-subdir';
-import { pick } from 'ramda';
-import { renderHelp } from 'render-help';
-import { writeYamlFile } from 'write-yaml-file';
-import { createDeployFiles } from './createDeployFiles.js';
-import { deployHook } from './deployHook.js';
-const FORCE_LEGACY_DEPLOY = 'force-legacy-deploy';
-export const shorthands = {
-    ...install.shorthands,
-    legacy: [`--config.${FORCE_LEGACY_DEPLOY}=true`],
-};
-const DEPLOY_OWN_OPTIONS = pick([FORCE_LEGACY_DEPLOY], configTypes);
-export function rcOptionsTypes() {
-    return {
-        ...install.rcOptionsTypes(),
-        ...DEPLOY_OWN_OPTIONS,
-    };
-}
-export function cliOptionsTypes() {
-    return {
-        ...install.cliOptionsTypes(),
-        ...DEPLOY_OWN_OPTIONS,
-    };
-}
-export const commandNames = ['deploy'];
-export const overridableByScript = true;
-export function help() {
-    return renderHelp({
-        description: 'Experimental! Deploy a package from a workspace',
-        url: docsUrl('deploy'),
-        usages: ['pnpm --filter=<deployed project name> deploy <target directory>'],
-        descriptionLists: [
-            {
-                title: 'Options',
-                list: [
-                    {
-                        description: "Packages in `devDependencies` won't be installed",
-                        name: '--prod',
-                        shortAlias: '-P',
-                    },
-                    {
-                        description: 'Only `devDependencies` are installed',
-                        name: '--dev',
-                        shortAlias: '-D',
-                    },
-                    {
-                        description: '`optionalDependencies` are not installed',
-                        name: '--no-optional',
-                    },
-                    {
-                        description: 'Force legacy deploy implementation',
-                        name: '--legacy',
-                    },
-                ],
-            },
-            FILTERING,
-        ],
-    });
-}
-export async function handler(opts, params) {
-    if (!opts.workspaceDir) {
-        let hint;
-        if (opts.rootProjectManifest?.scripts?.['deploy'] != null) {
-            hint = 'Maybe you wanted to invoke "pnpm run deploy"';
-        }
-        throw new PnpmError('CANNOT_DEPLOY', 'A deploy is only possible from inside a workspace', { hint });
-    }
-    const selectedProjects = Object.values(opts.selectedProjectsGraph ?? {});
-    if (selectedProjects.length === 0) {
-        throw new PnpmError('NOTHING_TO_DEPLOY', 'No project was selected for deployment');
-    }
-    if (selectedProjects.length > 1) {
-        throw new PnpmError('CANNOT_DEPLOY_MANY', 'Cannot deploy more than 1 project');
-    }
-    if (params.length !== 1) {
-        throw new PnpmError('INVALID_DEPLOY_TARGET', 'This command requires one parameter');
-    }
-    const selectedProject = selectedProjects[0].package;
-    const deployDirParam = params[0];
-    const deployDir = path.isAbsolute(deployDirParam) ? deployDirParam : path.join(opts.dir, deployDirParam);
-    validateDeployTarget(deployDir, {
-        dir: opts.dir,
-        force: opts.force,
-        projectDir: selectedProject.rootDir,
-        workspaceDir: opts.workspaceDir,
-    });
-    const normalizedDeployDir = path.resolve(deployDir);
-    const normalizedWorkspaceDir = path.resolve(opts.workspaceDir);
-    const workspaceChildTarget = isChildPath(normalizedDeployDir, normalizedWorkspaceDir);
-    if (workspaceChildTarget) {
-        createWorkspaceChildTargetParents(normalizedWorkspaceDir, normalizedDeployDir);
-    }
-    if (!isEmptyDirOrNothing(deployDir)) {
-        if (!opts.force) {
-            throw new PnpmError('DEPLOY_DIR_NOT_EMPTY', `Deploy path ${deployDir} is not empty`);
-        }
-        logger.warn({ message: 'using --force, deleting deploy path', prefix: deployDir });
-    }
-    if (workspaceChildTarget) {
-        validateWorkspaceChildTargetComponents(normalizedWorkspaceDir, normalizedDeployDir);
-    }
-    await rimraf(deployDir);
-    if (workspaceChildTarget) {
-        createWorkspaceChildTargetParents(normalizedWorkspaceDir, normalizedDeployDir);
-        createWorkspaceChildTargetDir(normalizedWorkspaceDir, normalizedDeployDir);
-    }
-    else {
-        await fs.promises.mkdir(deployDir, { recursive: true });
-    }
-    const includeOnlyPackageFiles = !opts.deployAllFiles;
-    await copyProject(selectedProject.rootDir, deployDir, { includeOnlyPackageFiles });
-    if (opts.sharedWorkspaceLockfile) {
-        const warning = opts.forceLegacyDeploy
-            ? 'Shared workspace lockfile detected but configuration forces legacy deploy implementation.'
-            : await deployFromSharedLockfile(opts, selectedProject, deployDir);
-        if (warning) {
-            globalWarn(warning);
-        }
-        else {
-            return;
-        }
-    }
-    const deployedProject = opts.allProjects?.find(({ rootDir }) => rootDir === selectedProject.rootDir);
-    if (deployedProject) {
-        deployedProject.modulesDir = path.relative(selectedProject.rootDir, path.join(deployDir, 'node_modules'));
-    }
-    await install.handler({
-        ...opts,
-        confirmModulesPurge: false,
-        // Deploy doesn't work with dedupePeerDependents=true currently as for deploy
-        // we need to select a single project for install, while dedupePeerDependents
-        // doesn't work with filters right now.
-        // Related issue: https://github.com/pnpm/pnpm/issues/6858
-        dedupePeerDependents: false,
-        // If enabled, dedupe-injected-deps will symlink workspace packages in the
-        // deployed dir to their original (non-deployed) directory in an attempt to
-        // dedupe workspace packages that don't need to be injected. The deployed
-        // dir shouldn't have symlinks to the original workspace. Disable
-        // dedupe-injected-deps to always inject workspace packages since copying is
-        // desirable.
-        dedupeInjectedDeps: false,
-        // Compute the wanted lockfile correctly by setting pruneLockfileImporters.
-        // Since pnpm deploy only installs dependencies for a single selected
-        // project, other projects in the "importers" lockfile section will be
-        // empty when node-linker=hoisted.
-        //
-        // For example, when deploying project-1, project-2 may not be populated,
-        // even if it has dependencies.
-        //
-        //   importers:
-        //     project-1:
-        //       dependencies:
-        //         foo:
-        //           specifier: ^1.0.0
-        //           version: ^1.0.0
-        //     project-2: {}
-        //
-        // Avoid including these empty importers in the in-memory wanted lockfile.
-        // This is important when node-linker=hoisted to prevent project-2 from
-        // being included in the hoisted install. If project-2 is errantly hoisted
-        // to the root node_modules dir, downstream logic will fail to inject it to
-        // the deploy directory. It's also just weird to include empty importers
-        // that don't matter to the filtered lockfile generated for pnpm deploy.
-        pruneLockfileImporters: true,
-        // The node_modules for a pnpm deploy should be self-contained. The global
-        // virtual store would create symlinks outside of the deploy directory.
-        enableGlobalVirtualStore: false,
-        depth: Infinity,
-        hooks: {
-            ...opts.hooks,
-            readPackage: [
-                ...(opts.hooks?.readPackage ?? []),
-                deployHook,
-            ],
-        },
-        frozenLockfile: false,
-        preferFrozenLockfile: false,
-        // Deploy doesn't work currently with hoisted node_modules.
-        // TODO: make it work as we need to prefer packages from the lockfile during deployment.
-        useLockfile: opts.nodeLinker !== 'hoisted',
-        saveLockfile: false,
-        virtualStoreDir: path.join(deployDir, 'node_modules/.pnpm'),
-        modulesDir: path.relative(opts.workspaceDir, path.join(deployDir, 'node_modules')),
-        includeOnlyPackageFiles,
-    });
-}
-async function copyProject(src, dest, opts) {
-    const { filesMap } = await fetchFromDir(src, opts);
-    const importPkg = createIndexedPkgImporter('clone-or-copy');
-    importPkg(dest, { filesMap, force: true, resolvedFrom: 'local-dir' });
-}
-function validateDeployTarget(deployDir, opts) {
-    const normalizedDeployDir = path.resolve(deployDir);
-    const workspaceDir = path.resolve(opts.workspaceDir);
-    const projectDir = path.resolve(opts.projectDir);
-    const dir = path.resolve(opts.dir);
-    if (samePath(normalizedDeployDir, workspaceDir)) {
-        throw unsafeDeployTarget(normalizedDeployDir, 'target is the workspace root');
-    }
-    if (isAncestorPath(normalizedDeployDir, workspaceDir)) {
-        throw unsafeDeployTarget(normalizedDeployDir, 'target contains the workspace root');
-    }
-    if (samePath(normalizedDeployDir, projectDir)) {
-        throw unsafeDeployTarget(normalizedDeployDir, 'target is the selected project root');
-    }
-    if (isAncestorPath(normalizedDeployDir, projectDir)) {
-        throw unsafeDeployTarget(normalizedDeployDir, 'target contains the selected project');
-    }
-    if (samePath(normalizedDeployDir, dir)) {
-        throw unsafeDeployTarget(normalizedDeployDir, 'target is the current directory');
-    }
-    if (isAncestorPath(normalizedDeployDir, dir)) {
-        throw unsafeDeployTarget(normalizedDeployDir, 'target contains the current directory');
-    }
-    if (opts.force && !isChildPath(normalizedDeployDir, workspaceDir)) {
-        throw unsafeDeployTarget(normalizedDeployDir, 'target is outside the workspace');
-    }
-    if (isChildPath(normalizedDeployDir, workspaceDir)) {
-        validateWorkspaceChildTargetComponents(workspaceDir, normalizedDeployDir);
-    }
-}
-function validateWorkspaceChildTargetComponents(workspaceDir, deployDir) {
-    const relative = path.relative(workspaceDir, deployDir);
-    let current = workspaceDir;
-    for (const component of relative.split(path.sep)) {
-        if (!component)
-            continue;
-        current = path.join(current, component);
-        let stat;
-        try {
-            stat = fs.lstatSync(current);
-        }
-        catch (error) {
-            if (isENOENT(error))
-                return;
-            throw error;
-        }
-        if (stat.isSymbolicLink()) {
-            throw unsafeDeployTarget(current, 'target path contains a symlink');
-        }
-    }
-}
-function createWorkspaceChildTargetParents(workspaceDir, deployDir) {
-    const parent = path.dirname(deployDir);
-    const relative = path.relative(workspaceDir, parent);
-    let current = workspaceDir;
-    for (const component of relative.split(path.sep)) {
-        if (!component)
-            continue;
-        current = path.join(current, component);
-        createWorkspaceChildTargetComponent(current);
-    }
-}
-function createWorkspaceChildTargetDir(workspaceDir, deployDir) {
-    try {
-        fs.mkdirSync(deployDir);
-    }
-    catch (error) {
-        if (isEEXIST(error)) {
-            throw unsafeDeployTarget(deployDir, 'target changed during deploy preparation');
-        }
-        throw error;
-    }
-    validateWorkspaceChildTargetComponents(workspaceDir, deployDir);
-}
-function createWorkspaceChildTargetComponent(component) {
-    try {
-        fs.mkdirSync(component);
-    }
-    catch (error) {
-        if (!isEEXIST(error))
-            throw error;
-    }
-    const stat = fs.lstatSync(component);
-    if (stat.isSymbolicLink()) {
-        throw unsafeDeployTarget(component, 'target path contains a symlink');
-    }
-    if (!stat.isDirectory()) {
-        throw unsafeDeployTarget(component, 'target path contains a non-directory');
-    }
-}
-function unsafeDeployTarget(deployDir, reason) {
-    return new PnpmError('INVALID_DEPLOY_TARGET', `Refusing to deploy to unsafe target ${deployDir}: ${reason}`);
-}
-function samePath(left, right) {
-    return path.normalize(left) === path.normalize(right);
-}
-function isAncestorPath(parent, child) {
-    return isChildPath(child, parent);
-}
-function isChildPath(child, parent) {
-    return !samePath(child, parent) && isSubdir(parent, child);
-}
-function isENOENT(error) {
-    return typeof error === 'object' && error != null && 'code' in error && error.code === 'ENOENT';
-}
-function isEEXIST(error) {
-    return typeof error === 'object' && error != null && 'code' in error && error.code === 'EEXIST';
-}
-async function deployFromSharedLockfile(opts, selectedProject, deployDir) {
-    if (!opts.injectWorkspacePackages) {
-        throw new PnpmError('DEPLOY_NONINJECTED_WORKSPACE', 'By default, starting from pnpm v10, we only deploy from workspaces that have "inject-workspace-packages=true" set', {
-            hint: 'If you want to deploy without using injected dependencies, run "pnpm deploy" with the "--legacy" flag or set "force-legacy-deploy" to true',
-        });
-    }
-    const { allProjects, lockfileDir, rootProjectManifestDir, workspaceDir, } = opts;
-    // The following errors should not be possible. It is a programmer error if they are reached.
-    if (!allProjects)
-        throw new Error('opts.allProjects is undefined.');
-    if (!lockfileDir)
-        throw new Error('opts.lockfileDir is undefined.');
-    if (!workspaceDir)
-        throw new Error('opts.workspaceDir is undefined.');
-    const lockfile = await readWantedLockfile(lockfileDir, { ignoreIncompatible: false });
-    if (!lockfile) {
-        return 'Shared lockfile not found. Falling back to installing without a lockfile.';
-    }
-    const projectId = getLockfileImporterId(lockfileDir, selectedProject.rootDir);
-    const deployFiles = createDeployFiles({
-        allProjects,
-        deployDir,
-        lockfile,
-        lockfileDir,
-        patchedDependencies: opts.patchedDependencies,
-        selectedProjectManifest: selectedProject.manifest,
-        projectId,
-        rootProjectManifestDir,
-        allowBuilds: opts.allowBuilds,
-    });
-    const filesToWrite = [
-        fs.promises.writeFile(path.join(deployDir, 'package.json'), JSON.stringify(deployFiles.manifest, undefined, 2) + '\n'),
-        writeWantedLockfile(deployDir, deployFiles.lockfile),
-    ];
-    if (deployFiles.workspaceManifest) {
-        filesToWrite.push(writeYamlFile(path.join(deployDir, WORKSPACE_MANIFEST_FILENAME), deployFiles.workspaceManifest));
-    }
-    await Promise.all(filesToWrite);
-    try {
-        await install.handler({
-            ...opts,
-            allProjects: undefined,
-            allProjectsGraph: undefined,
-            selectedProjectsGraph: undefined,
-            rootProjectManifest: deployFiles.manifest,
-            // The node_modules for a pnpm deploy should be self-contained. The global
-            // virtual store would create symlinks outside of the deploy directory.
-            enableGlobalVirtualStore: false,
-            rootProjectManifestDir: deployDir,
-            dir: deployDir,
-            lockfileDir: deployDir,
-            workspaceDir: undefined,
-            virtualStoreDir: undefined,
-            modulesDir: undefined,
-            confirmModulesPurge: false,
-            frozenLockfile: true,
-            injectWorkspacePackages: undefined, // the effects of injecting workspace packages should already be part of the package snapshots
-            overrides: undefined, // the effects of the overrides should already be part of the package snapshots
-            packageExtensions: undefined, // the effects of the package extensions should already be part of the package snapshots
-            configDependencies: undefined, // configDependencies (e.g. pacquet) are not installed into the deploy dir, so the install engine they designate isn't on disk to invoke
-            hooks: {
-                ...opts.hooks,
-                readPackage: [
-                    ...(opts.hooks?.readPackage ?? []),
-                    deployHook,
-                ],
-                calculatePnpmfileChecksum: undefined, // the effects of the pnpmfile should already be part of the package snapshots
-            },
-        });
-    }
-    catch (error) {
-        globalWarn(`Deployment with a shared lockfile has failed. If this is a bug, please report it at <https://github.com/pnpm/pnpm/issues>.
-As a workaround, add the following to pnpm-workspace.yaml:
-
-  forceLegacyDeploy: true`);
-        throw error;
-    }
-    return undefined;
-}
-//# sourceMappingURL=deploy.js.map

package/lib/deploy/deployHook.d.ts

@@ -1,2 +0,0 @@
-import { type BaseManifest } from '@pnpm/types';
-export declare function deployHook<Pkg extends BaseManifest>(pkg: Pkg): Pkg;

package/lib/deploy/deployHook.js

@@ -1,15 +0,0 @@
-import { DEPENDENCIES_FIELDS } from '@pnpm/types';
-export function deployHook(pkg) {
-    pkg.dependenciesMeta = pkg.dependenciesMeta ?? {};
-    for (const depField of DEPENDENCIES_FIELDS) {
-        for (const [depName, depVersion] of Object.entries(pkg[depField] ?? {})) {
-            if (depVersion.startsWith('workspace:')) {
-                pkg.dependenciesMeta[depName] = {
-                    injected: true,
-                };
-            }
-        }
-    }
-    return pkg;
-}
-//# sourceMappingURL=deployHook.js.map

package/lib/deploy/index.d.ts

@@ -1,2 +0,0 @@
-import * as deploy from './deploy.js';
-export { deploy };

package/lib/deploy/index.js

@@ -1,3 +0,0 @@
-import * as deploy from './deploy.js';
-export { deploy };
-//# sourceMappingURL=index.js.map

package/lib/index.d.ts

@@ -1,5 +0,0 @@
-export { deploy } from './deploy/index.js';
-export { packApp } from './pack-app/index.js';
-export { pack, publish } from './publish/index.js';
-export * as stage from './stage/index.js';
-export { version } from './version/index.js';

package/lib/pack-app/index.d.ts

@@ -1,2 +0,0 @@
-import * as packApp from './packApp.js';
-export { packApp };

package/lib/pack-app/index.js

@@ -1,3 +0,0 @@
-import * as packApp from './packApp.js';
-export { packApp };
-//# sourceMappingURL=index.js.map

package/lib/pack-app/packApp.d.ts

@@ -1,22 +0,0 @@
-import type { Config } from '@pnpm/config.reader';
-export declare const commandNames: string[];
-export declare function rcOptionsTypes(): Record<string, unknown>;
-export declare function cliOptionsTypes(): Record<string, unknown>;
-export declare const shorthands: Record<string, string>;
-export declare function help(): string;
-export type PackAppOptions = Pick<Config, 'dir' | 'pnpmHomeDir'> & Partial<Pick<Config, 'ca' | 'cert' | 'configByUri' | 'httpProxy' | 'httpsProxy' | 'key' | 'localAddress' | 'nodeDownloadMirrors' | 'noProxy' | 'strictSsl' | 'userAgent'>> & {
-    entry?: string;
-    target?: string | string[];
-    runtime?: string;
-    outputDir?: string;
-    outputName?: string;
-};
-export declare function handler(opts: PackAppOptions, params: string[]): Promise<string>;
-/** Fields pack-app reads from `pnpm.app` in package.json. */
-export interface ProjectAppConfig {
-    entry?: string;
-    targets?: string[];
-    runtime?: string;
-    outputDir?: string;
-    outputName?: string;
-}