import {execUtils, scriptUtils, structUtils, tgzUtils} from '@yarnpkg/core'; import {Locator, formatUtils} from '@yarnpkg/core'; import {Fetcher, FetchOptions, MinimalFetchOptions} from '@yarnpkg/core'; import {MessageName, ReportError} from '@yarnpkg/core'; import {PortablePath, npath, ppath, xfs, NativePath} from '@yarnpkg/fslib'; import {PROTOCOL} from './constants'; import {loadGeneratorFile} from './execUtils'; /** * Contains various useful details about the execution context. */ export interface ExecEnv { /** * The absolute path of the empty temporary directory. It is created before the script is invoked. */ tempDir: NativePath; /** * The absolute path of the empty build directory that will be compressed into an archive and stored within the cache. It is created before the script is invoked. */ buildDir: NativePath; /** * The stringified Locator identifying the generator package. */ locator: string; } export class ExecFetcher implements Fetcher { supports(locator: Locator, opts: MinimalFetchOptions) { if (!locator.reference.startsWith(PROTOCOL)) return false; return true; } getLocalPath(locator: Locator, opts: FetchOptions) { const {parentLocator, path} = structUtils.parseFileStyleRange(locator.reference, {protocol: PROTOCOL}); if (ppath.isAbsolute(path)) return path; const parentLocalPath = opts.fetcher.getLocalPath(parentLocator, opts); if (parentLocalPath === null) return null; return ppath.resolve(parentLocalPath, path); } async fetch(locator: Locator, opts: FetchOptions) { const expectedChecksum = opts.checksums.get(locator.locatorHash) || null; const [packageFs, releaseFs, checksum] = await opts.cache.fetchPackageFromCache(locator, expectedChecksum, { onHit: () => opts.report.reportCacheHit(locator), onMiss: () => opts.report.reportCacheMiss(locator), loader: () => this.fetchFromDisk(locator, opts), ...opts.cacheOptions, }); return { packageFs, releaseFs, prefixPath: structUtils.getIdentVendorPath(locator), localPath: this.getLocalPath(locator, opts), checksum, }; } private async fetchFromDisk(locator: Locator, opts: FetchOptions) { const dependencyMeta = opts.project.getDependencyMeta(locator, null); if (!opts.project.configuration.get(`enableScripts`) && !dependencyMeta.built) throw new ReportError(MessageName.DISABLED_BUILD_SCRIPTS, `${structUtils.prettyLocator(opts.project.configuration, locator)} can't be built with the exec: protocol because all scripts have been disabled.`); const generatorFile = await loadGeneratorFile(locator.reference, PROTOCOL, opts); return xfs.mktempPromise(async generatorDir => { const generatorPath = ppath.join(generatorDir, `generator.js`); await xfs.writeFilePromise(generatorPath, generatorFile); return xfs.mktempPromise(async cwd => { // Execute the specified script in the temporary directory await this.generatePackage(cwd, locator, generatorPath, opts); // Make sure the script generated the package if (!xfs.existsSync(ppath.join(cwd, `build`))) throw new Error(`The script should have generated a build directory`); return await tgzUtils.makeArchiveFromDirectory(ppath.join(cwd, `build`), { prefixPath: structUtils.getIdentVendorPath(locator), compressionLevel: opts.project.configuration.get(`compressionLevel`), }); }); }); } private async generatePackage(cwd: PortablePath, locator: Locator, generatorPath: PortablePath, opts: FetchOptions) { return await xfs.mktempPromise(async binFolder => { const env = await scriptUtils.makeScriptEnv({project: opts.project, binFolder}); const runtimeFile = ppath.join(cwd, `runtime.js`); return await xfs.mktempPromise(async logDir => { const logFile = ppath.join(logDir, `buildfile.log`); const tempDir = ppath.join(cwd, `generator`); const buildDir = ppath.join(cwd, `build`); await xfs.mkdirPromise(tempDir); await xfs.mkdirPromise(buildDir); /** * Values exposed on the global `execEnv` variable. * * Must be stringifiable using `JSON.stringify`. */ const execEnvValues: ExecEnv = { tempDir: npath.fromPortablePath(tempDir), buildDir: npath.fromPortablePath(buildDir), locator: structUtils.stringifyLocator(locator), }; await xfs.writeFilePromise(runtimeFile, ` // Expose 'Module' as a global variable Object.defineProperty(global, 'Module', { get: () => require('module'), configurable: true, enumerable: false, }); // Expose non-hidden built-in modules as global variables for (const name of Module.builtinModules.filter((name) => name !== 'module' && !name.startsWith('_'))) { Object.defineProperty(global, name, { get: () => require(name), configurable: true, enumerable: false, }); } // Expose the 'execEnv' global variable Object.defineProperty(global, 'execEnv', { value: { ...${JSON.stringify(execEnvValues)}, }, enumerable: true, }); `); let nodeOptions = env.NODE_OPTIONS || ``; const pnpRegularExpression = /\s*--require\s+\S*\.pnp\.c?js\s*/g; nodeOptions = nodeOptions.replace(pnpRegularExpression, ` `).trim(); env.NODE_OPTIONS = nodeOptions; const {stdout, stderr} = opts.project.configuration.getSubprocessStreams(logFile, { header: `# This file contains the result of Yarn generating a package (${structUtils.stringifyLocator(locator)})\n`, prefix: structUtils.prettyLocator(opts.project.configuration, locator), report: opts.report, }); const {code} = await execUtils.pipevp(process.execPath, [`--require`, npath.fromPortablePath(runtimeFile), npath.fromPortablePath(generatorPath), structUtils.stringifyIdent(locator)], {cwd, env, stdin: null, stdout, stderr}); if (code !== 0) { xfs.detachTemp(logDir); throw new Error(`Package generation failed (exit code ${code}, logs can be found here: ${formatUtils.pretty(opts.project.configuration, logFile, formatUtils.Type.PATH)})`); } }); }); } }