workspace-sieve
Version:
A flexible workspace package filter for monorepos
425 lines (417 loc) • 34.8 kB
JavaScript
;
var path = require('path');
var tinyglobby = require('tinyglobby');
var child_process = require('child_process');
var fsp = require('node:fs/promises');
var fs = require('fs');
// Pattern wasm ver
const instances = new Map();
let instanceCounter = 0;
const textEncoder = new TextEncoder();
const textDecoder = new TextDecoder();
const INPUT_MEMORY_OFFSET = 1024 * 4;
const INITIAL_BUFFER_SIZE = 8192;
const MAX_BUFFER_SIZE = 1024 * 1024 * 16;
function createZigEnv(instanceId) {
return {
logString: (ptr, len)=>{
const instance = instances.get(instanceId);
if (!instance || !instance.debugMode) {
return;
}
const memory = new Uint8Array(instance.module.memory.buffer);
const logText = textDecoder.decode(memory.subarray(ptr, ptr + len));
console.log(`[Instance ${instanceId} DEBUG]: ${logText}`);
},
logBytes: (ptr, len)=>{
const instance = instances.get(instanceId);
if (!instance || !instance.debugMode) {
return;
}
const memory = new Uint8Array(instance.module.memory.buffer);
const bytes = Array.from(memory.subarray(ptr, ptr + len));
console.log(`[Instance ${instanceId} BYTES]: ${bytes.join(', ')} (ASCII: '${bytes.map((b)=>b >= 32 && b < 127 ? String.fromCharCode(b) : '.').join('')}')`);
},
isDebugEnabled: ()=>{
const instance = instances.get(instanceId);
return instance ? instance.debugMode : false;
}
};
}
function loadWASM(debug) {
const instanceId = `wasm_${++instanceCounter}`;
const bytes = Uint8Array.from(atob("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"), (c)=>c.charCodeAt(0));
const compiled = new WebAssembly.Module(bytes);
const env = createZigEnv(instanceId);
const module = new WebAssembly.Instance(compiled, {
env
}).exports;
instances.set(instanceId, {
module,
debugMode: debug
});
return {
instanceId,
module,
debug
};
}
function writeStringsToMemory(module, strings, debugMode) {
const memoryOffset = 1024;
const mem = new Uint8Array(module.memory.buffer);
const lengths = [];
const encodedStrings = strings.map((str)=>textEncoder.encode(str));
let offset = memoryOffset;
for (const encoded of encodedStrings){
mem.set(encoded, offset);
mem[offset + encoded.length] = 0 // null terminator
;
lengths.push(encoded.length);
if (debugMode) {
const written = Array.from(mem.slice(offset, offset + encoded.length)).map((b)=>String.fromCharCode(b)).join('');
console.log(`[JS Written]: "${written}"`);
}
offset += encoded.length + 1;
}
return {
ptr: memoryOffset,
lengths
};
}
function createMatcher(patterns, debug = false) {
const { instanceId, module, debug: debugMode } = loadWASM(debug);
const contextPtr = module.createMatcherContext();
const { ptr, lengths } = writeStringsToMemory(module, patterns, debugMode);
const lengthsArray = new Uint32Array(lengths);
const lengthsPtr = INPUT_MEMORY_OFFSET + 2048;
let mem = new Uint8Array(module.memory.buffer);
mem.set(new Uint8Array(lengthsArray.buffer), lengthsPtr);
const matcherId = module.initMatcher(contextPtr, ptr, lengthsPtr, patterns.length);
let bufferSize = INITIAL_BUFFER_SIZE;
let inputBuffer = new Uint8Array(bufferSize);
return {
match: (input)=>{
const estimatedSize = input.length * 4 // UTF-8 can be up to 4 bytes per char
;
if (estimatedSize > bufferSize && estimatedSize < MAX_BUFFER_SIZE) {
bufferSize = Math.min(MAX_BUFFER_SIZE, Math.pow(2, Math.ceil(Math.log2(estimatedSize))));
inputBuffer = new Uint8Array(bufferSize);
}
let encodedLen;
if (estimatedSize <= bufferSize) {
const result = textEncoder.encodeInto(input, inputBuffer);
encodedLen = result.written || 0;
} else {
const encoded = textEncoder.encode(input);
encodedLen = encoded.length;
if (mem.buffer !== module.memory.buffer) {
mem = new Uint8Array(module.memory.buffer);
}
mem.set(encoded, INPUT_MEMORY_OFFSET);
return !!module.matchPattern(contextPtr, matcherId, INPUT_MEMORY_OFFSET, encodedLen);
}
if (mem.buffer !== module.memory.buffer) {
mem = new Uint8Array(module.memory.buffer);
}
mem.set(inputBuffer.subarray(0, encodedLen), INPUT_MEMORY_OFFSET);
return !!module.matchPattern(contextPtr, matcherId, INPUT_MEMORY_OFFSET, encodedLen);
},
dispose: ()=>{
module.disposeMatcher(contextPtr, matcherId);
module.destroyMatcherContext(contextPtr);
instances.delete(instanceId);
inputBuffer = null;
}
};
}
function createWorkspacePatternWASM(patterns, debug = false) {
const matcher = createMatcher(patterns, debug);
return {
match: (input)=>matcher.match(input),
dispose: ()=>matcher.dispose()
};
}
// We should respect pnpm's detection of binary files on different platforms.
const { platform: currentPlatform, arch: currentArch } = process;
function getCurrentLibc() {
if (currentPlatform !== 'linux') {
return 'unknown';
}
try {
const lddOutput = child_process.execSync('ldd --version 2>&1', {
encoding: 'utf8'
});
return lddOutput.includes('musl') ? 'musl' : 'glibc';
} catch {
return 'glibc';
}
}
function checkIsInstallable(metadata, supportedArchitectures) {
return ensurePlatform(metadata.dirPath, supportedArchitectures);
}
function ensurePlatform(packageName, supportedArchitectures) {
const { os = [
'current'
], cpu = [
'current'
], libc = [
'current'
] } = supportedArchitectures;
const resolvedOs = os.map((o)=>o === 'current' ? currentPlatform : o);
const resolvedCpu = cpu.map((c)=>c === 'current' ? currentArch : c);
const resolvedLibc = libc.map((l)=>l === 'current' ? getCurrentLibc() : l);
if (!resolvedOs.includes(currentPlatform)) {
throw new Error(`Package "${packageName}" is not compatible with current platform (${currentPlatform}). ` + `Supported platforms are: ${resolvedOs.join(', ')}`);
}
if (!resolvedCpu.includes(currentArch)) {
throw new Error(`Package "${packageName}" is not compatible with current CPU architecture (${currentArch}). ` + `Supported architectures are: ${resolvedCpu.join(', ')}`);
}
if (currentPlatform === 'linux') {
const currentLibc = getCurrentLibc();
if (!resolvedLibc.includes(currentLibc)) {
throw new Error(`Package "${packageName}" is not compatible with current libc (${currentLibc}). ` + `Supported libc types are: ${resolvedLibc.join(', ')}`);
}
}
}
function unique(arr) {
return Array.from(new Set(arr));
}
async function readJsonFile(filePath) {
const content = await fsp.readFile(filePath, 'utf8');
return JSON.parse(content);
}
const ROOT_FILES = [
'pnpm-workspace.yaml',
'lerna.json'
];
// npm: https://docs.npmjs.com/cli/v7/using-npm/workspaces#installing-workspaces
// yarn: https://classic.yarnpkg.com/en/docs/workspaces/#toc-how-to-use-it
function hasWorkspacePackageJSON(root) {
const s = path.join(root, 'package.json');
if (!isFileReadable(s)) {
return false;
}
try {
const content = JSON.parse(fs.readFileSync(s, 'utf-8')) || {};
return !!content.workspaces;
} catch {
return false;
}
}
function hasRootFile(root) {
return ROOT_FILES.some((file)=>fs.existsSync(path.join(root, file)));
}
function hasPackageJSON(root) {
const s = path.join(root, 'package.json');
return fs.existsSync(s);
}
function searchForPackageRoot(current, root = current) {
if (hasPackageJSON(current)) {
return current;
}
const dir = path.dirname(current);
// reach the fs root
if (!dir || dir === current) {
return root;
}
return searchForPackageRoot(dir, root);
}
function searchForWorkspaceRoot(current, root = searchForPackageRoot(current)) {
if (hasRootFile(current)) {
return current;
}
if (hasWorkspacePackageJSON(current)) {
return current;
}
const dir = path.dirname(current);
if (!dir || dir === current) {
return root;
}
return searchForWorkspaceRoot(dir, root);
}
function tryStatSync(file) {
try {
return fs.statSync(file, {
throwIfNoEntry: false
});
} catch {}
}
function isFileReadable(filename) {
if (!tryStatSync(filename)) {
return false;
}
try {
fs.accessSync(filename, fs.constants.R_OK);
return true;
} catch {
return false;
}
}
const DEFAULT_IGNORE = [
'**/node_modules/**',
'**/bower_components/**',
'**/test/**',
'**/tests/**'
];
async function findWorkspacePackages(wd, options) {
const globalOpts = {
...options,
cwd: wd,
expandDirectories: false
};
if (!globalOpts.ignore) {
globalOpts.ignore = DEFAULT_IGNORE;
}
const patterns = serializePattern(options?.patterns || [
'.',
'**'
]);
if ('patterns' in globalOpts) {
delete globalOpts.patterns;
}
const paths = tinyglobby.globSync(patterns, globalOpts);
const serializedManifestPaths = unique(paths.map((p)=>path.join(wd, p)).sort((a, b)=>a > b ? 1 : a < b ? -1 : 0));
const packagesMetadata = await Promise.all(serializedManifestPaths.map(readPackgeMetadata));
const supportedArchitectures = Object.assign({
os: [
'current'
],
cpu: [
'current'
],
libc: [
'current'
]
}, options?.supportedArchitectures);
const errorMsgs = [];
try {
for (const metadata of packagesMetadata){
checkIsInstallable(metadata, supportedArchitectures);
}
} catch (e) {
if (options?.verbose) {
switch(options.verbose){
case 'info':
{
console.error(e);
break;
}
case 'error':
{
errorMsgs.push(e);
break;
}
}
}
}
return {
packagesMetadata,
errorMsgs
};
}
function serializePattern(inputs) {
const patterns = [];
for (const pattern of inputs){
patterns.push(pattern.replace(/\/?$/, '/package.json'));
patterns.push(pattern.replace(/\/?$/, '/package.json5'));
patterns.push(pattern.replace(/\/?$/, '/package.yaml'));
}
return patterns;
}
// I can't find any description of the package manifest format in the npm or yarn documentation.
// It's a special case for pnpm.
async function readPackgeMetadata(manifestPath) {
const b = path.basename(manifestPath);
switch(b){
case 'package.json':
{
const manifest = await readJsonFile(manifestPath);
return {
manifest,
manifestPath,
dirPath: path.dirname(manifestPath)
};
}
default:
throw new Error(`Unsupported package manifest: ${b}`);
}
}
// TODO: handle workspace: * and etc...
function createWorkspacePackageGraphics(metadata) {
const graphics = metadata.reduce((acc, cur)=>(acc[cur.dirPath] = cur, acc), {});
return graphics;
}
async function filterWorkspacePackagesFromDirectory(workspaceRoot, options) {
const { packagesMetadata: allProjects } = await findWorkspacePackages(workspaceRoot, {
...options,
verbose: 'error'
});
const graphics = createWorkspacePackageGraphics(allProjects);
return {
allProjects,
...filterWorkspacePackagesByGraphics(graphics, options?.filter || [], {
experimental: options?.experimental
})
};
}
function filterWorkspacePackagesByGraphics(packageGraph, patterns, options) {
if (!patterns.length) {
return {
unmatchedFilters: [],
matchedProjects: [],
matchedGraphics: {}
};
}
const packageIds = Object.keys(packageGraph);
const unmatchedFilters = new Set();
const matchedProjects = new Set();
const matchedPaths = new Set();
const matchedGraphics = {};
const combinedMatcher = createWorkspacePatternWASM(patterns, options?.experimental?.debug || false);
for (const id of packageIds){
const pkg = packageGraph[id];
const pkgName = pkg.manifest.name;
const dirName = path.basename(pkg.dirPath);
if (matchedPaths.has(pkg.dirPath)) {
continue;
}
if (pkgName && combinedMatcher.match(pkgName)) {
matchedProjects.add(pkgName);
matchedGraphics[dirName] = pkg;
matchedPaths.add(pkg.dirPath);
}
if (combinedMatcher.match(dirName)) {
matchedProjects.add(pkgName || dirName);
matchedGraphics[dirName] = pkg;
matchedPaths.add(pkg.dirPath);
}
}
combinedMatcher.dispose();
for (const pattern of patterns){
const singleMatcher = createWorkspacePatternWASM([
pattern
], options?.experimental?.debug || false);
const hasMatch = packageIds.some((id)=>{
const pkg = packageGraph[id];
const pkgName = pkg.manifest.name;
const dirName = path.basename(pkg.dirPath);
return pkgName && singleMatcher.match(pkgName) || singleMatcher.match(dirName);
});
if (!hasMatch) {
unmatchedFilters.add(pattern);
}
singleMatcher.dispose();
}
return {
unmatchedFilters: Array.from(unmatchedFilters),
matchedProjects: Array.from(matchedProjects),
matchedGraphics
};
}
exports.DEFAULT_IGNORE = DEFAULT_IGNORE;
exports.createWorkspacePatternWASM = createWorkspacePatternWASM;
exports.filterWorkspacePackagesByGraphics = filterWorkspacePackagesByGraphics;
exports.filterWorkspacePackagesFromDirectory = filterWorkspacePackagesFromDirectory;
exports.findWorkspacePackages = findWorkspacePackages;
exports.searchForPackageRoot = searchForPackageRoot;
exports.searchForWorkspaceRoot = searchForWorkspaceRoot;