@hubspot/cli 8.0.3-experimental.1 → 8.0.4-experimental.0

package/lib/projects/workspaces.js

@@ -1,224 +0,0 @@
-import fs from 'fs-extra';
-import path from 'path';
-import crypto from 'crypto';
-import { shouldIgnoreFile } from '@hubspot/local-dev-lib/ignoreRules';
-import { getPackableFiles, } from '@hubspot/project-parsing-lib/workspaces';
-import { uiLogger } from '../ui/logger.js';
-import { lib } from '../../lang/en.js';
-/**
- * Generates a short hash of the input string for use in workspace paths.
- * Uses SHA256 truncated to 8 hex characters (4 billion possibilities).
- */
-export function shortHash(input) {
-    return crypto.createHash('sha256').update(input).digest('hex').slice(0, 8);
-}
-/**
- * Determines the archive path for an external workspace or file: dependency.
- * Produces `_workspaces/<basename>-<hash>` with no subdirectory.
- * The hash prevents collisions between different directories with the same basename.
- */
-export function computeExternalArchivePath(absolutePath) {
-    const resolved = path.resolve(absolutePath);
-    const name = path.basename(resolved);
-    return path.join('_workspaces', `${name}-${shortHash(resolved)}`);
-}
-/**
- * Returns true if dir is inside srcDir (i.e. it will already be included
- * in the archive from the srcDir walk and must not be copied again).
- */
-function isInsideSrcDir(dir, srcDir) {
-    const rel = path.relative(path.resolve(srcDir), path.resolve(dir));
-    return !rel.startsWith('..') && !path.isAbsolute(rel);
-}
-/**
- * Creates a file filter function for workspace archiving.
- * Filters files based on packable files list and ignore rules.
- */
-function createWorkspaceFileFilter(packableFiles) {
-    return (file) => {
-        if (packableFiles.size > 0 && !packableFiles.has(file.name)) {
-            uiLogger.debug(lib.projectUpload.handleProjectUpload.fileFiltered(file.name));
-            return false;
-        }
-        const ignored = shouldIgnoreFile(file.name, true);
-        if (ignored) {
-            uiLogger.debug(lib.projectUpload.handleProjectUpload.fileFiltered(file.name));
-            return false;
-        }
-        return file;
-    };
-}
-/**
- * Archives workspace directories and returns mapping information.
- *
- * Internal workspaces (inside srcDir) are not archived — they are already
- * included via the srcDir walk. Their relative paths (from the package.json
- * directory to the workspace directory) are stored directly in the entries.
- *
- * External workspaces (outside srcDir) are copied to `_workspaces/<name>-<hash>`
- * and their absolute archive paths (`/_workspaces/<name>-<hash>`) are stored.
- */
-async function archiveWorkspaceDirectories(archive, srcDir, workspaceMappings) {
-    const externalArchivePaths = new Map(); // resolvedDir -> archivePath
-    const archivePathToDir = new Map(); // archivePath -> resolvedDir (collision detection)
-    const packageWorkspaceEntries = new Map();
-    const externalsToArchive = [];
-    for (const mapping of workspaceMappings) {
-        const { workspaceDir, sourcePackageJsonPath } = mapping;
-        if (!packageWorkspaceEntries.has(sourcePackageJsonPath)) {
-            packageWorkspaceEntries.set(sourcePackageJsonPath, []);
-        }
-        if (isInsideSrcDir(workspaceDir, srcDir)) {
-            // Internal: already in archive from srcDir walk.
-            // Store the relative path from the package.json directory so npm can resolve it.
-            const relPath = path.relative(path.dirname(sourcePackageJsonPath), path.resolve(workspaceDir));
-            packageWorkspaceEntries.get(sourcePackageJsonPath).push(relPath);
-        }
-        else {
-            // External: archive to _workspaces/<name>-<hash>.
-            const archivePath = computeExternalArchivePath(workspaceDir);
-            const resolvedDir = path.resolve(workspaceDir);
-            // Detect hash collisions (different dirs mapping to the same archive path)
-            const existing = archivePathToDir.get(archivePath);
-            if (existing && existing !== resolvedDir) {
-                throw new Error(lib.projectUpload.handleProjectUpload.workspaceCollision(archivePath, workspaceDir, existing));
-            }
-            if (!externalArchivePaths.has(resolvedDir)) {
-                externalArchivePaths.set(resolvedDir, archivePath);
-                archivePathToDir.set(archivePath, resolvedDir);
-                externalsToArchive.push({ dir: workspaceDir, archivePath });
-            }
-            // Store absolute archive path so DFS can locate it in the project tree
-            packageWorkspaceEntries
-                .get(sourcePackageJsonPath)
-                .push(`/${archivePath}`);
-        }
-    }
-    // Fetch packable files in parallel (I/O optimization)
-    const withPackableFiles = await Promise.all(externalsToArchive.map(async (item) => ({
-        ...item,
-        packableFiles: await getPackableFiles(item.dir),
-    })));
-    // Archive directories sequentially (archiver requires sequential operations)
-    for (const { dir, archivePath, packableFiles } of withPackableFiles) {
-        uiLogger.log(lib.projectUpload.handleProjectUpload.workspaceIncluded(dir, archivePath));
-        archive.directory(dir, archivePath, createWorkspaceFileFilter(packableFiles));
-    }
-    return { externalArchivePaths, packageWorkspaceEntries };
-}
-/**
- * Archives file: dependencies and returns mapping information.
- *
- * Internal file: dependencies (inside srcDir) are skipped — their original
- * `file:` references in package.json remain valid after upload.
- *
- * External file: dependencies are archived to `_workspaces/<name>-<hash>`
- * and tracked in the returned map so package.json can be rewritten.
- */
-async function archiveFileDependencies(archive, srcDir, fileDependencyMappings, externalArchivePaths) {
-    const packageFileDeps = new Map();
-    const toArchive = [];
-    for (const mapping of fileDependencyMappings) {
-        const { packageName, localPath, sourcePackageJsonPath } = mapping;
-        if (isInsideSrcDir(localPath, srcDir)) {
-            // Internal: original file: reference stays unchanged, nothing to do
-            continue;
-        }
-        // External: archive to _workspaces/<name>-<hash>
-        const archivePath = computeExternalArchivePath(localPath);
-        const resolvedPath = path.resolve(localPath);
-        if (!packageFileDeps.has(sourcePackageJsonPath)) {
-            packageFileDeps.set(sourcePackageJsonPath, new Map());
-        }
-        packageFileDeps.get(sourcePackageJsonPath).set(packageName, archivePath);
-        // Only archive each unique path once
-        if (!externalArchivePaths.has(resolvedPath)) {
-            externalArchivePaths.set(resolvedPath, archivePath);
-            toArchive.push({ localPath, archivePath, packageName });
-        }
-    }
-    // Fetch packable files in parallel (I/O optimization)
-    const withPackableFiles = await Promise.all(toArchive.map(async (item) => ({
-        ...item,
-        packableFiles: await getPackableFiles(item.localPath),
-    })));
-    // Archive directories sequentially (archiver requires sequential operations)
-    for (const { localPath, archivePath, packageName, packableFiles, } of withPackableFiles) {
-        uiLogger.log(lib.projectUpload.handleProjectUpload.fileDependencyIncluded(packageName, localPath, archivePath));
-        archive.directory(localPath, archivePath, createWorkspaceFileFilter(packableFiles));
-    }
-    return packageFileDeps;
-}
-/**
- * Updates package.json files in the archive to reflect new workspace and file: dependency paths.
- *
- * Workspace entries in packageWorkspaces are already in final form:
- * - Internal workspaces: relative paths (e.g. "../packages/utils")
- * - External workspaces: absolute paths (e.g. "/_workspaces/logger-abc")
- *
- * Only external file: dependencies appear in packageFileDeps; internal ones
- * keep their original file: references and are left untouched.
- */
-export async function updatePackageJsonInArchive(archive, srcDir, packageWorkspaces, packageFileDeps) {
-    // Collect all package.json paths that need updating
-    const allPackageJsonPaths = new Set([
-        ...packageWorkspaces.keys(),
-        ...packageFileDeps.keys(),
-    ]);
-    for (const packageJsonPath of allPackageJsonPaths) {
-        if (!fs.existsSync(packageJsonPath)) {
-            continue;
-        }
-        let packageJson;
-        try {
-            packageJson = JSON.parse(fs.readFileSync(packageJsonPath, 'utf8'));
-        }
-        catch (e) {
-            uiLogger.warn(lib.projectUpload.handleProjectUpload.malformedPackageJson(packageJsonPath, e instanceof Error ? e.message : String(e)));
-            continue;
-        }
-        const relativePackageJsonPath = path.relative(srcDir, packageJsonPath);
-        let modified = false;
-        // Update workspaces field — entries are already in their final form
-        const workspaceEntries = packageWorkspaces.get(packageJsonPath);
-        if (workspaceEntries && packageJson.workspaces) {
-            packageJson.workspaces = workspaceEntries;
-            modified = true;
-            uiLogger.debug(lib.projectUpload.handleProjectUpload.updatingPackageJsonWorkspaces(relativePackageJsonPath));
-            uiLogger.debug(lib.projectUpload.handleProjectUpload.updatedWorkspaces(workspaceEntries.join(', ')));
-        }
-        // Update external file: dependencies; internal ones are left untouched
-        const fileDeps = packageFileDeps.get(packageJsonPath);
-        if (fileDeps && fileDeps.size > 0 && packageJson.dependencies) {
-            for (const [packageName, archivePath] of fileDeps.entries()) {
-                if (packageJson.dependencies[packageName]?.startsWith('file:')) {
-                    packageJson.dependencies[packageName] = `file:/${archivePath}`;
-                    modified = true;
-                    uiLogger.debug(lib.projectUpload.handleProjectUpload.updatedFileDependency(packageName, `/${archivePath}`));
-                }
-            }
-        }
-        if (modified) {
-            // Add modified package.json to archive (will replace the original)
-            archive.append(JSON.stringify(packageJson, null, 2), {
-                name: relativePackageJsonPath,
-            });
-        }
-    }
-    // Ensure all append operations are queued before finalize is called
-    // Use setImmediate to yield control and let archiver process the queue
-    await new Promise(resolve => setImmediate(resolve));
-}
-/**
- * Main orchestration function that handles archiving of workspaces and file dependencies.
- * This is the clean integration point for upload.ts.
- */
-export async function archiveWorkspacesAndDependencies(archive, srcDir, projectDir, workspaceMappings, fileDependencyMappings) {
-    // Archive workspace directories (internal ones are skipped, externals are copied)
-    const { externalArchivePaths, packageWorkspaceEntries } = await archiveWorkspaceDirectories(archive, srcDir, workspaceMappings);
-    // Archive external file: dependencies (internals are skipped)
-    const packageFileDeps = await archiveFileDependencies(archive, srcDir, fileDependencyMappings, externalArchivePaths);
-    // Update package.json files with new paths
-    await updatePackageJsonInArchive(archive, srcDir, packageWorkspaceEntries, packageFileDeps);
-    return { packageWorkspaces: packageWorkspaceEntries, packageFileDeps };
-}