@prosopo/config 3.4.2 → 3.4.3

package/src/dependencies.ts

@@ -1,259 +0,0 @@
-// Copyright 2021-2026 Prosopo (UK) Ltd.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-import child_process from "node:child_process";
-import fs from "node:fs";
-import path from "node:path";
-import util from "node:util";
-import type { ProjectReference } from "typescript";
-
-const exec = util.promisify(child_process.exec);
-const peerDepsRegex = /UNMET\sOPTIONAL\sDEPENDENCY\s+(@*[\w\-/.]+)@/;
-const depsRegex = /\s+(@*[\w\-/.]+)@/;
-
-const getTsconfigDir = (tsConfigPath: string): string =>
-	".json" === path.extname(tsConfigPath)
-		? path.dirname(tsConfigPath)
-		: tsConfigPath;
-
-async function getPackageDir(packageName: string): Promise<string> {
-	let pkg = packageName;
-	if (packageName && !packageName.startsWith("@prosopo/")) {
-		pkg = `@prosopo/${packageName}`;
-	}
-	const pkgCommand = `npm list ${pkg} -ap`;
-	console.info(`Running command ${pkgCommand}`);
-	// get package directory
-	const { stdout: packageDir, stderr } = await exec(pkgCommand);
-	if (stderr) {
-		if (stderr.includes("ERR!")) {
-			throw new Error("CONFIG.INVALID_PACKAGE_DIR");
-		}
-	}
-	return packageDir.trim() || path.resolve();
-}
-
-/**
- * Resolve the tsconfig path for a reference using the initial tsconfig path and the reference path. If the reference
- * does not contain a tsconfig filename, `tsconfig.json` will be appended to the path.
- * @param initialTsConfigPath
- * @param reference
- */
-function getReferenceTsConfigPath(
-	initialTsConfigPath: string,
-	reference: ProjectReference,
-) {
-	// remove tsconfig.*.json from the path and get the path to the new directory via the reference path
-	let refTSConfigPath = path.resolve(
-		getTsconfigDir(initialTsConfigPath),
-		reference.path,
-	);
-	if (!refTSConfigPath.endsWith(".json")) {
-		refTSConfigPath = path.resolve(refTSConfigPath, "tsconfig.json");
-	}
-	return refTSConfigPath;
-}
-
-/**
- * Get the tsconfig paths for a package
- * @param tsConfigPath the tsconfig path to start with
- * @param ignorePatterns the patterns to ignore
- * @param tsConfigPaths the tsconfig paths to add to
- * @param includeInitialTsConfig return the initial tsconfig path in the returned array
- */
-export function getTsConfigs(
-	tsConfigPath: string,
-	ignorePatterns: RegExp[] = [],
-	tsConfigPaths: string[] = [],
-	includeInitialTsConfig = true,
-): string[] {
-	let tsConfigs = [...tsConfigPaths];
-	//TODO use dynamic import with JSON assertion (TS complains that resolveJsonModule is not set)
-	const references = JSON.parse(
-		fs.readFileSync(tsConfigPath).toString(),
-	).references;
-	if (!tsConfigs.includes(tsConfigPath)) {
-		if (references) {
-			const ignore =
-				ignorePatterns && ignorePatterns.length > 0
-					? new RegExp(`${ignorePatterns.join("|")}`)
-					: undefined;
-			if (includeInitialTsConfig) {
-				tsConfigs.push(tsConfigPath);
-			}
-
-			// ignore the packages we don't want to bundle
-			const filteredReferences = references.filter(
-				(reference: ProjectReference) =>
-					ignore ? !ignore.test(reference.path) : false,
-			);
-			// for each reference, get the tsconfig paths - recursively calling this function
-			for (const reference of filteredReferences) {
-				// remove tsconfig.*.json from the path and get the path to the new directory via the reference path
-				const refTSConfigPath = getReferenceTsConfigPath(
-					tsConfigPath,
-					reference,
-				);
-
-				// take the reference TS config path (refTSConfigPath) and get the tsconfig paths for it (newTsConfigs),
-				// adding both to a distinct list, as there may be duplicates
-				const newTsConfigs = getTsConfigs(
-					refTSConfigPath,
-					ignorePatterns,
-					tsConfigs,
-				);
-				if (newTsConfigs.length > 0) {
-					const distinctTsConfigPaths = new Set(tsConfigs.concat(newTsConfigs));
-					tsConfigs = [...distinctTsConfigPaths];
-				}
-			}
-		}
-	}
-	return tsConfigs;
-}
-
-/**
- * Get the workspace externals for a package
- * @param tsConfigPath
- * @param ignorePatterns
- */
-export async function getExternalsFromReferences(
-	tsConfigPath: string,
-	ignorePatterns: RegExp[] = [],
-): Promise<string[]> {
-	const tsConfigPaths = getTsConfigs(tsConfigPath, ignorePatterns, [], false);
-	console.debug({ tsConfigPaths });
-	const promises: Promise<string>[] = [];
-	for (const refTsConfigPath of tsConfigPaths) {
-		const packageJsonPath = path.resolve(
-			getTsconfigDir(refTsConfigPath),
-			"package.json",
-		);
-		promises.push(
-			new Promise((resolve, reject) => {
-				// if package.json exists, read it and get the package name
-				fs.stat(packageJsonPath, (err) => {
-					if (err) {
-						reject(err);
-					}
-					fs.readFile(packageJsonPath, (err, buffer) => {
-						if (err) {
-							reject(err);
-						} else {
-							const packageJson = JSON.parse(buffer.toString());
-							const pkg = packageJson.name;
-							resolve(pkg);
-						}
-					});
-				});
-			}),
-		);
-	}
-	const externals = await Promise.all(promises);
-	console.debug({ externals });
-	return externals;
-}
-
-/**
- * Get the dependencies for a package
- * @param packageName
- * @param production
- */
-export async function getDependencies(
-	packageName?: string,
-	production?: boolean,
-): Promise<{ dependencies: string[]; optionalPeerDependencies: string[] }> {
-	let cmd = production
-		? "npm ls -a --silent --omit=dev --package-lock-only"
-		: "npm ls --silent -a --package-lock-only";
-
-	if (packageName) {
-		const packageDir = await getPackageDir(packageName);
-		cmd = `cd ${packageDir.trim()} && ${cmd}`;
-		console.info(`Running command ${cmd} in ${packageDir}`);
-	}
-
-	let concat = "";
-	// `npm ls` exits non-zero on any invalid/unmet/extraneous dependency (e.g.
-	// Vite 8's optional `yaml` peer being satisfied by a hoisted v1 from
-	// cosmiconfig). It still prints the full tree to stdout in that case, so we
-	// tolerate the non-zero exit and parse whatever was emitted.
-	try {
-		const { stdout, stderr } = await exec(cmd);
-		concat = stdout + stderr;
-	} catch (error) {
-		const execError = error as { stdout?: string; stderr?: string };
-		if (typeof execError.stdout === "string") {
-			concat = execError.stdout + (execError.stderr ?? "");
-		} else {
-			throw error;
-		}
-	}
-
-	let deps: string[] = [];
-	let peerDeps: string[] = [];
-	// for each line, check if there is an unmet optional dependency
-	for (const line of concat.split("\n")) {
-		if (line.includes("UNMET OPTIONAL DEPENDENCY")) {
-			//  │ │ │   ├── UNMET OPTIONAL DEPENDENCY bufferutil@^4.0.1
-			const parts = line.match(peerDepsRegex);
-			if (parts && parts.length > 1) {
-				peerDeps.push(parts[1] as string);
-			}
-		} else {
-			//  │ │ │ ├─┬ mongodb-memory-server-core@8.15.1
-			const parts = line.match(depsRegex);
-			if (parts && parts.length > 1) {
-				deps.push(parts[1] as string);
-			}
-		}
-	}
-
-	// ensure deps and peerDeps are unique
-	deps = [...new Set(deps)];
-	peerDeps = [...new Set(peerDeps)];
-
-	// dedupe and return deps and peer deps
-	return {
-		dependencies: deps.filter((x, i) => i === deps.indexOf(x)),
-		optionalPeerDependencies: peerDeps.filter(
-			(x, i) => i === peerDeps.indexOf(x),
-		),
-	};
-}
-
-/**
- * Filter out the dependencies we don't want
- * @param deps
- * @param filters
- */
-export function filterDependencies(
-	deps: string[],
-	filters: string[],
-): { internal: string[]; external: string[] } {
-	const depsDeduped = deps.filter((x, i) => i === deps.indexOf(x));
-	const depsWithLength = depsDeduped.filter((dep) => dep.length > 0).sort();
-	const exclude = new RegExp(`${filters.join("|")}`);
-	// filter out the deps we don't want
-	const internal: string[] = [];
-	const external: string[] = [];
-	for (const dep of depsWithLength) {
-		if (exclude.test(dep)) {
-			external.push(dep);
-		} else {
-			internal.push(dep);
-		}
-	}
-	return { internal, external };
-}

package/src/getDependencies.test.ts

@@ -1,385 +0,0 @@
-// Copyright 2021-2026 Prosopo (UK) Ltd.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-import type { ExecException } from "node:child_process";
-import path from "node:path";
-import { promisify } from "node:util";
-import type { UserConfig } from "vite";
-import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
-
-/** What `npm ls` handed back for a given command. */
-interface ExecResult {
-	stdout: string;
-	stderr: string;
-}
-
-type ExecCallback = (
-	error: ExecException | null,
-	stdout: string,
-	stderr: string,
-) => void;
-
-/** Commands seen, in order, so the tests can assert on what was run. */
-let commands: string[] = [];
-/** Queue of responses, consumed one per `exec` call. */
-let responses: (ExecResult | Error)[] = [];
-
-const fakeExec = (command: string, callback: ExecCallback): void => {
-	commands.push(command);
-	const next = responses.shift();
-	if (next === undefined) {
-		throw new Error(`unexpected exec: ${command}`);
-	}
-	if (next instanceof Error) {
-		callback(next, "", "");
-		return;
-	}
-	callback(null, next.stdout, next.stderr);
-};
-
-// `util.promisify` honours this symbol, which is how the real
-// `child_process.exec` resolves to `{ stdout, stderr }` rather than to stdout
-// alone. The mock has to provide it or the promisified call shape differs from
-// production.
-Object.defineProperty(fakeExec, promisify.custom, {
-	value: (command: string): Promise<ExecResult> =>
-		new Promise((resolve, reject) => {
-			fakeExec(command, (error, stdout, stderr) => {
-				if (error) {
-					reject(error);
-				} else {
-					resolve({ stdout, stderr });
-				}
-			});
-		}),
-});
-
-vi.mock("node:child_process", () => ({ default: { exec: fakeExec } }));
-
-const { getDependencies } = await import("./dependencies.js");
-
-beforeEach(() => {
-	commands = [];
-	responses = [];
-});
-
-afterEach(() => {
-	expect(responses).toEqual([]);
-});
-
-const ok = (stdout: string, stderr = ""): ExecResult => ({ stdout, stderr });
-
-/** `util.promisify` reads stdout/stderr off the error for a failing exec. */
-const failing = (stdout: string, stderr = ""): Error => {
-	const error: ExecException & { stdout?: string; stderr?: string } =
-		Object.assign(new Error("npm ls exited 1"), { stdout, stderr });
-	return error;
-};
-
-const TREE = [
-	"@prosopo/root@1.0.0 /repo",
-	"├─┬ mongodb@6.3.0",
-	"│ └── bson@6.2.0",
-	"└── zod@3.22.4",
-].join("\n");
-
-describe("getDependencies", () => {
-	it("parses every package name out of the npm ls tree", async () => {
-		responses = [ok(TREE)];
-		const { dependencies } = await getDependencies();
-		expect(dependencies).toEqual(["mongodb", "bson", "zod"]);
-	});
-
-	it("does not treat the root package line as a dependency", async () => {
-		// The root line has no leading whitespace, which is what the regex keys
-		// off — a package must never externalise itself.
-		responses = [ok(TREE)];
-		const { dependencies } = await getDependencies();
-		expect(dependencies).not.toContain("@prosopo/root");
-	});
-
-	it("collects unmet optional peers separately", async () => {
-		responses = [
-			ok(
-				[
-					"│ ├── UNMET OPTIONAL DEPENDENCY bufferutil@^4.0.1",
-					"│ ├── UNMET OPTIONAL DEPENDENCY utf-8-validate@^5.0.2",
-					"└── zod@3.22.4",
-				].join("\n"),
-			),
-		];
-		const { dependencies, optionalPeerDependencies } = await getDependencies();
-		expect(optionalPeerDependencies).toEqual(["bufferutil", "utf-8-validate"]);
-		expect(dependencies).toEqual(["zod"]);
-	});
-
-	it("deduplicates packages that appear all over the tree", async () => {
-		responses = [ok(["├── zod@3.22.4", "│ └── zod@3.22.4"].join("\n"))];
-		await expect(getDependencies()).resolves.toEqual({
-			dependencies: ["zod"],
-			optionalPeerDependencies: [],
-		});
-	});
-
-	it("returns empty lists for an empty tree", async () => {
-		responses = [ok("")];
-		await expect(getDependencies()).resolves.toEqual({
-			dependencies: [],
-			optionalPeerDependencies: [],
-		});
-	});
-
-	it("omits dev dependencies when asked for a production tree", async () => {
-		responses = [ok(TREE)];
-		await getDependencies(undefined, true);
-		expect(commands[0]).toContain("--omit=dev");
-	});
-
-	it("keeps dev dependencies otherwise", async () => {
-		responses = [ok(TREE)];
-		await getDependencies(undefined, false);
-		expect(commands[0]).not.toContain("--omit=dev");
-	});
-
-	it("resolves the package directory first and runs npm ls inside it", async () => {
-		responses = [ok("/repo/packages/server\n"), ok(TREE)];
-		await getDependencies("@prosopo/server");
-		expect(commands[0]).toBe("npm list @prosopo/server -ap");
-		expect(commands[1]).toContain("cd /repo/packages/server &&");
-	});
-
-	it("prefixes a bare package name with the scope", async () => {
-		responses = [ok("/repo/packages/server\n"), ok(TREE)];
-		await getDependencies("server");
-		expect(commands[0]).toBe("npm list @prosopo/server -ap");
-	});
-
-	it("leaves an already-scoped name alone", async () => {
-		responses = [ok("/repo/packages/server\n"), ok(TREE)];
-		await getDependencies("@prosopo/server");
-		expect(commands[0]).toBe("npm list @prosopo/server -ap");
-	});
-
-	it("falls back to the working directory when npm prints no path", async () => {
-		responses = [ok("  \n"), ok(TREE)];
-		await getDependencies("@prosopo/server");
-		expect(commands[1]).toContain(`cd ${process.cwd()} &&`);
-	});
-
-	it("rejects when the package cannot be located", async () => {
-		responses = [ok("", "npm ERR! code E404")];
-		await expect(getDependencies("@prosopo/absent")).rejects.toThrow(
-			"CONFIG.INVALID_PACKAGE_DIR",
-		);
-	});
-
-	it("tolerates npm warnings on stderr that are not errors", async () => {
-		responses = [
-			ok("/repo/packages/server\n", "npm warn deprecated"),
-			ok(TREE),
-		];
-		await expect(getDependencies("@prosopo/server")).resolves.toMatchObject({
-			dependencies: ["mongodb", "bson", "zod"],
-		});
-	});
-
-	it("still parses the tree when npm ls exits non-zero", async () => {
-		// `npm ls` exits 1 for any unmet or extraneous dependency but still
-		// prints the whole tree, so the build must not be blocked by it.
-		responses = [failing(TREE)];
-		const { dependencies } = await getDependencies();
-		expect(dependencies).toEqual(["mongodb", "bson", "zod"]);
-	});
-
-	it("rethrows when a failing npm ls produced no output at all", async () => {
-		const error: ExecException = new Error("npm not found");
-		responses = [error];
-		await expect(getDependencies()).rejects.toThrow("npm not found");
-	});
-
-	it("reads stderr as well as stdout, since npm splits the tree across both", async () => {
-		responses = [ok("├── zod@3.22.4", "\n└── axios@1.6.0")];
-		const { dependencies } = await getDependencies();
-		expect(dependencies).toEqual(["zod", "axios"]);
-	});
-});
-
-const { default: ViteBackendConfig } = await import(
-	"./vite/vite.backend.config.js"
-);
-
-/** Every backend config starts with the same two npm ls calls. */
-const npmLsResponses = (): (ExecResult | Error)[] => [
-	ok("/repo/packages/server\n"),
-	ok(TREE),
-];
-
-const externalsOf = (config: UserConfig): string[] => {
-	const external = config.build?.rollupOptions?.external;
-	if (!Array.isArray(external)) {
-		throw new Error("expected an array of externals");
-	}
-	return external.map(String);
-};
-
-// Hand-rolled rather than `.flat(Infinity)`: a non-literal depth makes tsc
-// expand FlatArray until it gives up with TS2589.
-const flattenDeep = (value: unknown): unknown[] =>
-	Array.isArray(value) ? value.flatMap(flattenDeep) : [value];
-
-const pluginNamesOf = (plugins: UserConfig["plugins"]): string[] =>
-	flattenDeep(plugins ?? []).map((plugin) => {
-		if (plugin && typeof plugin === "object" && "name" in plugin) {
-			return String(plugin.name);
-		}
-		return "";
-	});
-
-describe("ViteBackendConfig", () => {
-	const build = (
-		command?: string,
-		mode?: string,
-		outputDir?: string,
-	): Promise<UserConfig> => {
-		responses = npmLsResponses();
-		return ViteBackendConfig(
-			"@prosopo/server",
-			"1.2.3",
-			"server",
-			"/repo/packages/server",
-			"src/index.ts",
-			command,
-			mode,
-			outputDir,
-		);
-	};
-
-	it("emits an esm bundle named after the bundle name", async () => {
-		const config = await build();
-		expect(config.build?.lib).toMatchObject({
-			name: "server",
-			formats: ["es"],
-			fileName: "server.[name].bundle.js",
-		});
-		expect(config.build?.rollupOptions?.output).toMatchObject({
-			entryFileNames: "server.[name].bundle.js",
-		});
-	});
-
-	it("defaults the output to dist/bundle inside the package", async () => {
-		const config = await build();
-		expect(config.build?.outDir).toBe(
-			path.resolve("/repo/packages/server", "dist/bundle"),
-		);
-	});
-
-	it("honours an explicit output directory", async () => {
-		const config = await build(undefined, undefined, "/tmp/out");
-		expect(config.build?.outDir).toBe(path.resolve("/tmp/out"));
-	});
-
-	it("minifies only in production", async () => {
-		await expect(build(undefined, "production")).resolves.toMatchObject({
-			build: { minify: true },
-		});
-		await expect(build(undefined, "development")).resolves.toMatchObject({
-			build: { minify: false },
-		});
-	});
-
-	it("bakes the package version into the bundle", async () => {
-		const config = await build();
-		expect(config.define).toMatchObject({
-			"process.env.PROSOPO_PACKAGE_VERSION": '"1.2.3"',
-		});
-	});
-
-	it("stubs out the optional websocket native helpers", async () => {
-		// bufferutil and utf-8-validate are optional native deps; without these
-		// flags ws tries to require them and the bundle dies at boot.
-		const config = await build();
-		expect(config.define).toMatchObject({
-			"process.env.WS_NO_BUFFER_UTIL": "true",
-			"process.env.WS_NO_UTF_8_VALIDATE": "true",
-		});
-	});
-
-	it("bundles punycode rather than externalising it", async () => {
-		// The provider image ships no node_modules, so an external deep import
-		// like "punycode/punycode.es6.js" is an immediate boot failure.
-		const config = await build();
-		expect(externalsOf(config)).not.toContain("punycode");
-		expect(externalsOf(config)).toContain("node:punycode");
-	});
-
-	it("externalises the remaining node builtins", async () => {
-		const list = externalsOf(await build());
-		expect(list).toContain("fs");
-		expect(list).toContain("node:fs");
-	});
-
-	it("resolves the entry against the package directory", async () => {
-		const config = await build();
-		expect(config.build?.lib).toMatchObject({
-			entry: [path.resolve("/repo/packages/server", "src/index.ts")],
-		});
-	});
-
-	it("resolves a list of entries", async () => {
-		responses = npmLsResponses();
-		const config = await ViteBackendConfig(
-			"@prosopo/server",
-			"1.2.3",
-			"server",
-			"/repo/packages/server",
-			["src/a.ts", "src/b.ts"],
-		);
-		expect(config.build?.lib).toMatchObject({
-			entry: [
-				path.resolve("/repo/packages/server", "src/a.ts"),
-				path.resolve("/repo/packages/server", "src/b.ts"),
-			],
-		});
-	});
-
-	it("resolves a named entry map", async () => {
-		responses = npmLsResponses();
-		const config = await ViteBackendConfig(
-			"@prosopo/server",
-			"1.2.3",
-			"server",
-			"/repo/packages/server",
-			{ cli: "src/cli.ts" },
-		);
-		expect(config.build?.lib).toMatchObject({
-			entry: { cli: path.resolve("/repo/packages/server", "src/cli.ts") },
-		});
-	});
-
-	it("skips the close plugin while serving, so the dev server stays up", async () => {
-		const serving = (await build("serve")).plugins ?? [];
-		const building = (await build("build")).plugins ?? [];
-		expect(pluginNamesOf(serving)).not.toContain("close-plugin");
-		expect(pluginNamesOf(building)).toContain("close-plugin");
-	});
-
-	it("keeps module side effects when treeshaking", async () => {
-		// Dropping them broke polyfills that register themselves on import.
-		const config = await build();
-		expect(config.build?.rollupOptions?.treeshake).toMatchObject({
-			annotations: true,
-			moduleSideEffects: true,
-		});
-	});
-});

package/src/index.ts

@@ -1,16 +0,0 @@
-// Copyright 2021-2026 Prosopo (UK) Ltd.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-export * from "./vite/index.js";
-export * from "./dependencies.js";
-export * from "./webpack/index.js";