Skip to content

Commit 07fe1f6

Browse files
codenemcodenem
committed
Stop using JavascriptProject.resolveAll
1 parent be3157a commit 07fe1f6

File tree

2 files changed

+48
-230
lines changed

2 files changed

+48
-230
lines changed

‎packages/cli-v3/src/commands/deploy.ts

Lines changed: 18 additions & 33 deletions
Original file line numberDiff line numberDiff line change
@@ -56,7 +56,7 @@ import {
5656
parseBuildErrorStack,
5757
parseNpmInstallError,
5858
} from "../utilities/deployErrors";
59-
import { JavascriptProject } from "../utilities/javascriptProject";
59+
import { DependencyMeta, JavascriptProject } from "../utilities/javascriptProject";
6060
import { docs, getInTouch } from "../utilities/links";
6161
import { cliRootPath } from "../utilities/resolveInternalFilePath";
6262
import { safeJsonParse } from "../utilities/safeJsonParse";
@@ -1170,6 +1170,9 @@ async function compileProject(
11701170
);
11711171
}
11721172

1173+
const javascriptProject = new JavascriptProject(config.projectDir);
1174+
const directDependenciesMeta = await javascriptProject.extractDirectDependenciesMeta();
1175+
11731176
const result = await build({
11741177
stdin: {
11751178
contents: workerContents,
@@ -1327,17 +1330,16 @@ async function compileProject(
13271330
// Save the entryPoint outputFile to /tmp/dir/index.js
13281331
await writeFile(join(tempDir, "index.js"), entryPointOutputFile.text);
13291332

1330-
logger.debug("Getting the imports for the worker and entryPoint builds", {
1333+
logger.debug("Imports for the worker and entryPoint builds", {
13311334
workerImports: metaOutput.imports,
13321335
entryPointImports: entryPointMetaOutput.imports,
13331336
});
13341337

1335-
// Get all the required dependencies from the metaOutputs and save them to /tmp/dir/package.json
1336-
const allImports = [...metaOutput.imports, ...entryPointMetaOutput.imports];
1337-
1338-
const javascriptProject = new JavascriptProject(config.projectDir);
1339-
1340-
const dependencies = await resolveRequiredDependencies(allImports, config, javascriptProject);
1338+
const dependencies = await resolveRequiredDependencies(
1339+
directDependenciesMeta,
1340+
config,
1341+
javascriptProject
1342+
);
13411343

13421344
logger.debug("gatherRequiredDependencies()", { dependencies });
13431345

@@ -1707,36 +1709,19 @@ export async function typecheckProject(config: ResolvedConfig) {
17071709
// Returns the dependencies that are required by the output that are found in output and the CLI package dependencies
17081710
// Returns the dependency names and the version to use (taken from the CLI deps package.json)
17091711
export async function resolveRequiredDependencies(
1710-
imports: Metafile["outputs"][string]["imports"],
1712+
directDependenciesMeta: Record<string, DependencyMeta>,
17111713
config: ResolvedConfig,
17121714
project: JavascriptProject
17131715
) {
17141716
return await tracer.startActiveSpan("resolveRequiredDependencies", async (span) => {
1715-
const resolvablePackageNames = new Set<string>();
1716-
1717-
for (const file of imports) {
1718-
if ((file.kind !== "require-call" && file.kind !== "dynamic-import") || !file.external) {
1719-
continue;
1720-
}
1717+
span.setAttribute("resolvablePackageNames", Object.keys(directDependenciesMeta));
17211718

1722-
const packageName = detectPackageNameFromImportPath(file.path);
1723-
1724-
if (!packageName) {
1725-
continue;
1726-
}
1727-
1728-
resolvablePackageNames.add(packageName);
1729-
}
1730-
1731-
span.setAttribute("resolvablePackageNames", Array.from(resolvablePackageNames));
1732-
1733-
const resolvedPackageVersions = await project.resolveAll(Array.from(resolvablePackageNames));
1734-
const missingPackages = Array.from(resolvablePackageNames).filter(
1735-
(packageName) => !resolvedPackageVersions[packageName]
1736-
);
1719+
const missingPackages = Object.entries(directDependenciesMeta)
1720+
.filter(([, pkgMeta]) => !pkgMeta.version)
1721+
.map(([name]) => name);
17371722

17381723
span.setAttributes({
1739-
...flattenAttributes(resolvedPackageVersions, "resolvedPackageVersions"),
1724+
...flattenAttributes(directDependenciesMeta, "resolvedPackageVersions"),
17401725
});
17411726
span.setAttribute("missingPackages", missingPackages);
17421727

@@ -1752,8 +1737,8 @@ export async function resolveRequiredDependencies(
17521737
}
17531738
}
17541739

1755-
for (const [packageName, version] of Object.entries(resolvedPackageVersions)) {
1756-
dependencies[packageName] = version;
1740+
for (const [pkgName, { version }] of Object.entries(directDependenciesMeta)) {
1741+
dependencies[pkgName] = version;
17571742
}
17581743

17591744
if (config.additionalPackages) {

‎packages/cli-v3/src/utilities/javascriptProject.ts

Lines changed: 30 additions & 197 deletions
Original file line numberDiff line numberDiff line change
@@ -106,86 +106,51 @@ export class JavascriptProject {
106106
});
107107

108108
try {
109-
span.end();
110-
return await command.extractDirectDependenciesMeta({
109+
const packagesMeta = await command.extractDirectDependenciesMeta({
111110
cwd: this.projectPath,
112111
});
113-
} catch (error) {
114-
recordSpanException(span, error);
115-
span.end();
116-
117-
logger.debug(`Failed to resolve internal dependencies using ${command.name}`, {
118-
error,
119-
});
120112

121-
throw error;
122-
}
123-
}
124-
);
125-
}
126-
127-
async resolveAll(packageNames: string[]): Promise<Record<string, string>> {
128-
return tracer.startActiveSpan("JavascriptProject.resolveAll", async (span) => {
129-
const externalPackages = packageNames.filter((packageName) => !isBuiltInModule(packageName));
113+
// Merge the resolved versions with the package.json dependencies
114+
const missingPackagesMeta = Object.entries(packagesMeta).filter(
115+
([, { version }]) => !version
116+
);
117+
const missingPackageVersions: Record<string, string> = {};
130118

131-
const command = await this.#getCommand();
132-
133-
span.setAttributes({
134-
externalPackages,
135-
packageManager: command.name,
136-
});
119+
for (const [packageName, { external }] of missingPackagesMeta) {
120+
const packageJsonVersion = this.packageJson.dependencies?.[packageName];
137121

138-
try {
139-
const versions = await command.resolveDependencyVersions(externalPackages, {
140-
cwd: this.projectPath,
141-
});
122+
if (typeof packageJsonVersion === "string") {
123+
logger.debug(`Resolved ${packageName} version using package.json`, {
124+
packageJsonVersion,
125+
});
142126

143-
if (versions) {
144-
logger.debug(`Resolved [${externalPackages.join(", ")}] version using ${command.name}`, {
145-
versions,
146-
});
127+
packagesMeta[packageName] = { version: packageJsonVersion, external };
128+
missingPackageVersions[packageName] = packageJsonVersion;
129+
}
130+
}
147131

148132
span.setAttributes({
149-
...flattenAttributes(versions, "versions"),
133+
...flattenAttributes(missingPackageVersions, "missingPackageVersions"),
134+
missingPackages: missingPackagesMeta.map(
135+
([pkgName]: [string, DependencyMeta]) => pkgName
136+
),
150137
});
151-
}
152138

153-
// Merge the resolved versions with the package.json dependencies
154-
const missingPackages = externalPackages.filter((packageName) => !versions[packageName]);
155-
const missingPackageVersions: Record<string, string> = {};
139+
span.end();
156140

157-
for (const packageName of missingPackages) {
158-
const packageJsonVersion = this.packageJson.dependencies?.[packageName];
141+
return packagesMeta;
142+
} catch (error) {
143+
recordSpanException(span, error);
144+
span.end();
159145

160-
if (typeof packageJsonVersion === "string") {
161-
logger.debug(`Resolved ${packageName} version using package.json`, {
162-
packageJsonVersion,
163-
});
146+
logger.debug(`Failed to resolve internal dependencies using ${command.name}`, {
147+
error,
148+
});
164149

165-
missingPackageVersions[packageName] = packageJsonVersion;
166-
}
150+
throw error;
167151
}
168-
169-
span.setAttributes({
170-
...flattenAttributes(missingPackageVersions, "missingPackageVersions"),
171-
missingPackages,
172-
});
173-
174-
span.end();
175-
176-
return { ...versions, ...missingPackageVersions };
177-
} catch (error) {
178-
recordSpanException(span, error);
179-
span.end();
180-
181-
logger.debug(`Failed to resolve dependency versions using ${command.name}`, {
182-
packageNames,
183-
error,
184-
});
185-
186-
return {};
187152
}
188-
});
153+
);
189154
}
190155

191156
async resolve(packageName: string, options?: ResolveOptions): Promise<string | undefined> {
@@ -292,11 +257,6 @@ interface PackageManagerCommands {
292257
packageName: string,
293258
options: PackageManagerOptions
294259
): Promise<string | undefined>;
295-
296-
resolveDependencyVersions(
297-
packageNames: string[],
298-
options: PackageManagerOptions
299-
): Promise<Record<string, string>>;
300260
}
301261

302262
class PNPMCommands implements PackageManagerCommands {
@@ -330,30 +290,6 @@ class PNPMCommands implements PackageManagerCommands {
330290
}
331291
}
332292

333-
async resolveDependencyVersions(
334-
packageNames: string[],
335-
options: PackageManagerOptions
336-
): Promise<Record<string, string>> {
337-
const result = await this.#listDependencies(packageNames, options);
338-
339-
logger.debug(`Resolving ${packageNames.join(" ")} version using ${this.name}`);
340-
341-
const results: Record<string, string> = {};
342-
343-
// Return the first dependency version that matches the package name
344-
for (const dep of result) {
345-
for (const packageName of packageNames) {
346-
const dependency = dep.dependencies?.[packageName];
347-
348-
if (dependency) {
349-
results[packageName] = dependency.version;
350-
}
351-
}
352-
}
353-
354-
return results;
355-
}
356-
357293
async extractDirectDependenciesMeta(options: PackageManagerOptions) {
358294
const result = await this.#listDirectDependencies(options);
359295

@@ -393,21 +329,6 @@ class PNPMCommands implements PackageManagerCommands {
393329

394330
return JSON.parse(childProcess.stdout) as PnpmList;
395331
}
396-
397-
async #listDependencies(packageNames: string[], options: PackageManagerOptions) {
398-
const childProcess = await $({
399-
cwd: options.cwd,
400-
reject: false,
401-
})`${this.cmd} list ${packageNames} -r --json`;
402-
403-
if (childProcess.failed) {
404-
logger.debug("Failed to list dependencies, using stdout anyway...", {
405-
error: childProcess,
406-
});
407-
}
408-
409-
return JSON.parse(childProcess.stdout) as PnpmList;
410-
}
411332
}
412333

413334
type NpmDependency = {
@@ -446,27 +367,6 @@ class NPMCommands implements PackageManagerCommands {
446367
return this.#recursivelySearchDependencies(output.dependencies, packageName);
447368
}
448369

449-
async resolveDependencyVersions(
450-
packageNames: string[],
451-
options: PackageManagerOptions
452-
): Promise<Record<string, string>> {
453-
const output = await this.#listDependencies(packageNames, options);
454-
455-
logger.debug(`Resolving ${packageNames.join(" ")} version using ${this.name}`, { output });
456-
457-
const results: Record<string, string> = {};
458-
459-
for (const packageName of packageNames) {
460-
const version = this.#recursivelySearchDependencies(output.dependencies, packageName);
461-
462-
if (version) {
463-
results[packageName] = version;
464-
}
465-
}
466-
467-
return results;
468-
}
469-
470370
async extractDirectDependenciesMeta(
471371
options: PackageManagerOptions
472372
): Promise<Record<string, DependencyMeta>> {
@@ -492,21 +392,6 @@ class NPMCommands implements PackageManagerCommands {
492392
return JSON.parse(childProcess.stdout) as NpmListOutput;
493393
}
494394

495-
async #listDependencies(packageNames: string[], options: PackageManagerOptions) {
496-
const childProcess = await $({
497-
cwd: options.cwd,
498-
reject: false,
499-
})`${this.cmd} list ${packageNames} --json`;
500-
501-
if (childProcess.failed) {
502-
logger.debug("Failed to list dependencies, using stdout anyway...", {
503-
error: childProcess,
504-
});
505-
}
506-
507-
return JSON.parse(childProcess.stdout) as NpmListOutput;
508-
}
509-
510395
#recursivelySearchDependencies(
511396
dependencies: Record<string, NpmDependency>,
512397
packageName: string
@@ -575,31 +460,6 @@ class YarnCommands implements PackageManagerCommands {
575460
}
576461
}
577462

578-
async resolveDependencyVersions(
579-
packageNames: string[],
580-
options: PackageManagerOptions
581-
): Promise<Record<string, string>> {
582-
const stdout = await this.#listDependencies(packageNames, options);
583-
584-
const lines = stdout.split("\n");
585-
586-
logger.debug(`Resolving ${packageNames.join(" ")} version using ${this.name}`);
587-
588-
const results: Record<string, string> = {};
589-
590-
for (const line of lines) {
591-
const json = JSON.parse(line);
592-
593-
const packageName = this.#parseYarnValueIntoPackageName(json.value);
594-
595-
if (packageNames.includes(packageName)) {
596-
results[packageName] = json.children.Version;
597-
}
598-
}
599-
600-
return results;
601-
}
602-
603463
async extractDirectDependenciesMeta(options: PackageManagerOptions) {
604464
const result = await this.#listDirectDependencies(options);
605465

@@ -633,37 +493,10 @@ class YarnCommands implements PackageManagerCommands {
633493
return childProcess.stdout;
634494
}
635495

636-
async #listDependencies(packageNames: string[], options: PackageManagerOptions) {
637-
const childProcess = await $({
638-
cwd: options.cwd,
639-
reject: false,
640-
})`${this.cmd} info ${packageNames} --json`;
641-
642-
if (childProcess.failed) {
643-
logger.debug("Failed to list dependencies, using stdout anyway...", {
644-
error: childProcess,
645-
});
646-
}
647-
648-
return childProcess.stdout;
649-
}
650-
651496
// The "value" when doing yarn info is formatted like this:
652497
// "package-name@npm:version" or "package-name@workspace:version"
653498
// This function will parse the value into just the package name.
654499
// This correctly handles scoped packages as well e.g. @scope/package-name@npm:version
655-
#parseYarnValueIntoPackageName(value: string): string {
656-
const parts = value.split("@");
657-
658-
// If the value does not contain an "@" symbol, then it's just the package name
659-
if (parts.length === 3) {
660-
return parts[1] as string;
661-
}
662-
663-
// If the value contains an "@" symbol, then the package name is the first part
664-
return parts[0] as string;
665-
}
666-
667500
#parseYarnValueIntoDependencyMeta(value: string): [string, DependencyMeta] {
668501
const parts = value.split("@");
669502
let name: string, protocol: string, version: string;

0 commit comments

Comments
 (0)