@hubspot/project-parsing-lib 0.2.0 → 0.2.1-experimental.0

package/src/lib/workspaces.js

@@ -0,0 +1,290 @@
+import fs from 'fs';
+import fsPromises from 'fs/promises';
+import path from 'path';
+import os from 'os';
+import { glob } from 'glob';
+import packlist from 'npm-packlist';
+import { logger } from '@hubspot/local-dev-lib/logger';
+import { walk } from '@hubspot/local-dev-lib/fs';
+import { createMinimalTree } from './minimalArboristTree.js';
+/**
+ * Error thrown when a workspace directory cannot be resolved
+ */
+export class WorkspaceResolutionError extends Error {
+    workspaceDir;
+    sourcePackageJson;
+    constructor(workspaceDir, sourcePackageJson, cause) {
+        super(`Failed to resolve workspace directory "${workspaceDir}" declared in ${sourcePackageJson}${cause ? `: ${cause.message}` : ''}`);
+        this.workspaceDir = workspaceDir;
+        this.sourcePackageJson = sourcePackageJson;
+        this.name = 'WorkspaceResolutionError';
+        if (cause) {
+            this.cause = cause;
+        }
+    }
+}
+/**
+ * Error thrown when a file: dependency cannot be resolved
+ */
+export class FileDependencyResolutionError extends Error {
+    packageName;
+    dependencyPath;
+    sourcePackageJson;
+    constructor(packageName, dependencyPath, sourcePackageJson, cause) {
+        super(`Failed to resolve file: dependency "${packageName}" at path "${dependencyPath}" declared in ${sourcePackageJson}${cause ? `: ${cause.message}` : ''}`);
+        this.packageName = packageName;
+        this.dependencyPath = dependencyPath;
+        this.sourcePackageJson = sourcePackageJson;
+        this.name = 'FileDependencyResolutionError';
+        if (cause) {
+            this.cause = cause;
+        }
+    }
+}
+/**
+ * Expands tilde (~) in paths to the user's home directory
+ */
+function expandTildePath(filePath) {
+    return filePath.startsWith('~')
+        ? path.join(os.homedir(), filePath.slice(1))
+        : filePath;
+}
+/**
+ * Finds and parses all package.json files in a directory.
+ * This is the single entry point for discovering package.json files and parsing their contents.
+ */
+export async function findAndParsePackageJsonFiles(srcDir) {
+    const allFiles = await walk(srcDir, ['node_modules']);
+    const packageJsonPaths = allFiles.filter(file => path.basename(file) === 'package.json');
+    return packageJsonPaths.map(filePath => {
+        try {
+            return {
+                path: filePath,
+                dir: path.dirname(filePath),
+                content: JSON.parse(fs.readFileSync(filePath, 'utf8')),
+            };
+        }
+        catch (e) {
+            logger.debug(`Failed to parse package.json at ${filePath}: ${e}`);
+            return {
+                path: filePath,
+                dir: path.dirname(filePath),
+                content: null,
+            };
+        }
+    });
+}
+/**
+ * Extracts workspace patterns from parsed package.json content
+ */
+function extractWorkspaceGlobs(packageJson) {
+    const workspaces = packageJson.workspaces;
+    if (!workspaces) {
+        return [];
+    }
+    // Handle array format: "workspaces": ["packages/*"]
+    if (Array.isArray(workspaces)) {
+        return workspaces;
+    }
+    // Handle object format: "workspaces": {"packages": ["packages/*"]}
+    if (workspaces.packages && Array.isArray(workspaces.packages)) {
+        return workspaces.packages;
+    }
+    return [];
+}
+/**
+ * Resolves workspace glob patterns to actual directories
+ */
+export async function resolveWorkspaceDirectories(baseDir, workspaceGlobs) {
+    const resolvedDirs = new Set();
+    for (const pattern of workspaceGlobs) {
+        const expandedPattern = expandTildePath(pattern);
+        const absolutePattern = path.resolve(baseDir, expandedPattern);
+        try {
+            // Use glob to find matching directories
+            const matches = await glob(absolutePattern, {
+                absolute: true,
+                withFileTypes: false,
+            });
+            // Filter to directories that contain package.json
+            for (const match of matches) {
+                try {
+                    const stats = await fsPromises.stat(match);
+                    if (stats.isDirectory()) {
+                        const packageJsonPath = path.join(match, 'package.json');
+                        try {
+                            await fsPromises.access(packageJsonPath, fs.constants.F_OK);
+                            resolvedDirs.add(match);
+                        }
+                        catch {
+                            // Directory exists but doesn't contain package.json - skip silently
+                        }
+                    }
+                }
+                catch (e) {
+                    // Inaccessible directories may indicate permission issues or broken symlinks
+                    logger.warn(`Cannot access directory ${match}: ${e}`);
+                }
+            }
+        }
+        catch (e) {
+            logger.debug(`Failed to resolve workspace pattern "${pattern}": ${e}`);
+        }
+    }
+    return Array.from(resolvedDirs);
+}
+/**
+ * Collects all workspace directories that need to be uploaded.
+ * Handles edge cases like circular references, symlinks, and overlapping paths.
+ * Returns mappings that track which package.json defined each workspace.
+ */
+export async function collectWorkspaceDirectories(parsedPackageJsons) {
+    const workspaceMappings = [];
+    // Track (sourcePackageJsonPath, workspaceDir) pairs to avoid duplicates within
+    // the same source, while still allowing the same workspace dir to appear in
+    // mappings from multiple different package.json files. This ensures every
+    // package.json that declares a workspace gets its workspaces field rewritten,
+    // regardless of whether another package.json already references the same dir.
+    const visited = new Set();
+    for (const parsed of parsedPackageJsons) {
+        if (!parsed.content) {
+            continue;
+        }
+        const workspaceGlobs = extractWorkspaceGlobs(parsed.content);
+        if (workspaceGlobs.length === 0) {
+            continue;
+        }
+        logger.debug(`Found workspaces in ${parsed.path}: ${workspaceGlobs.join(', ')}`);
+        const resolved = await resolveWorkspaceDirectories(parsed.dir, workspaceGlobs);
+        for (const dir of resolved) {
+            // Resolve symlinks to real path
+            let realDir;
+            try {
+                realDir = await fsPromises.realpath(dir);
+            }
+            catch (e) {
+                throw new WorkspaceResolutionError(dir, parsed.path, e instanceof Error ? e : undefined);
+            }
+            // Skip duplicate (source, workspace) pairs only — the same workspace dir
+            // may legitimately be referenced by multiple package.json files and each
+            // needs its own mapping so its workspaces field is rewritten correctly.
+            const pairKey = `${parsed.path}::${realDir}`;
+            if (visited.has(pairKey)) {
+                logger.debug(`Skipping duplicate workspace mapping: ${realDir} from ${parsed.path}`);
+                continue;
+            }
+            visited.add(pairKey);
+            // Include all workspaces - both internal (inside srcDir) and external.
+            // The CLI determines the archive path:
+            // - Internal: preserved as-is (already included via srcDir walk)
+            // - External: _workspaces/<name>-<hash>
+            workspaceMappings.push({
+                workspaceDir: realDir,
+                sourcePackageJsonPath: parsed.path,
+            });
+            logger.debug(`Resolved workspace: ${realDir}`);
+        }
+    }
+    return workspaceMappings;
+}
+/**
+ * Extracts file: dependencies from parsed package.json content.
+ * Only scans production dependencies since devDependencies and optionalDependencies
+ * are not needed for the build pipeline.
+ */
+function extractFileDependencies(packageJson) {
+    const fileDeps = [];
+    const deps = packageJson.dependencies;
+    if (!deps) {
+        return fileDeps;
+    }
+    for (const [packageName, version] of Object.entries(deps)) {
+        // Only handle file: dependencies. workspace: dependencies reference packages
+        // already collected via the workspaces field, so they don't need separate handling.
+        if (typeof version === 'string' && version.startsWith('file:')) {
+            const filePath = version.slice(5); // Remove 'file:' prefix
+            fileDeps.push({ packageName, filePath });
+        }
+    }
+    return fileDeps;
+}
+/**
+ * Collects all file: dependencies that need to be uploaded.
+ * Returns mappings that track the package name, resolved path, and source package.json.
+ */
+export async function collectFileDependencies(parsedPackageJsons) {
+    const fileDependencyMappings = [];
+    const visited = new Set();
+    for (const parsed of parsedPackageJsons) {
+        if (!parsed.content) {
+            continue;
+        }
+        const fileDeps = extractFileDependencies(parsed.content);
+        if (fileDeps.length === 0) {
+            continue;
+        }
+        logger.debug(`Found file: dependencies in ${parsed.path}: ${fileDeps.map(d => d.packageName).join(', ')}`);
+        for (const { packageName, filePath } of fileDeps) {
+            const expandedPath = expandTildePath(filePath);
+            const absolutePath = path.resolve(parsed.dir, expandedPath);
+            // Resolve symlinks to real path
+            let realPath;
+            try {
+                realPath = await fsPromises.realpath(absolutePath);
+            }
+            catch (e) {
+                throw new FileDependencyResolutionError(packageName, absolutePath, parsed.path, e instanceof Error ? e : undefined);
+            }
+            // Verify it's a directory with a package.json
+            const stats = await fsPromises.stat(realPath);
+            if (!stats.isDirectory()) {
+                throw new FileDependencyResolutionError(packageName, realPath, parsed.path, new Error('Path is not a directory'));
+            }
+            const depPackageJsonPath = path.join(realPath, 'package.json');
+            try {
+                await fsPromises.access(depPackageJsonPath, fs.constants.F_OK);
+            }
+            catch {
+                throw new FileDependencyResolutionError(packageName, realPath, parsed.path, new Error('Directory does not contain package.json'));
+            }
+            // Skip if already visited (same path referenced multiple times)
+            if (visited.has(realPath)) {
+                logger.debug(`Skipping already visited file: dependency: ${realPath}`);
+                continue;
+            }
+            visited.add(realPath);
+            // Include all file: dependencies - both internal (inside srcDir) and external
+            // The CLI determines the archive path:
+            // - Internal: _workspaces/<relative-path>
+            // - External: _workspaces/external/<name>-<hash>
+            fileDependencyMappings.push({
+                packageName,
+                localPath: realPath,
+                sourcePackageJsonPath: parsed.path,
+            });
+            logger.debug(`Resolved file: dependency ${packageName}: ${realPath}`);
+        }
+    }
+    return fileDependencyMappings;
+}
+/**
+ * Returns the set of files that npm would include when publishing a package.
+ * Uses npm-packlist which respects the "files" field in package.json,
+ * .npmignore, and .gitignore rules.
+ *
+ * @throws Error if packlist fails to generate the file list
+ */
+export async function getPackableFiles(dir) {
+    try {
+        const tree = createMinimalTree(dir);
+        // Cast to Parameters<typeof packlist>[0] since npm-packlist only uses
+        // a subset of the Arborist Node properties at runtime
+        const files = await packlist(tree);
+        return new Set(files);
+    }
+    catch (e) {
+        const errorMessage = `Failed to get packlist for ${dir}: ${e instanceof Error ? e.message : String(e)}`;
+        logger.error(errorMessage);
+        throw new Error(errorMessage, { cause: e });
+    }
+}

package/src/index.d.ts

@@ -1,18 +0,0 @@
-import { IntermediateRepresentation, IntermediateRepresentationNode, IntermediateRepresentationLocalDev, TranslationContext, TranslationOptions, IntermediateRepresentationNodeLocalDev } from './lib/types';
-import { ValidateFunction, AnySchema, ErrorObject } from 'ajv/dist/2020';
-export declare function translate(translationContext: TranslationContext, translationOptions?: TranslationOptions): Promise<IntermediateRepresentation>;
-export declare function translateForLocalDev(translationContext: TranslationContext, translationOptions?: Pick<TranslationOptions, 'profile'>): Promise<IntermediateRepresentationLocalDev>;
-export { isTranslationError } from './lib/errors';
-export { IntermediateRepresentation, IntermediateRepresentationNode, IntermediateRepresentationLocalDev, IntermediateRepresentationNodeLocalDev, TranslationContext, };
-export { getHsProfileFilename } from './lib/profiles';
-export { loadHsProfileFile, getAllHsProfiles } from './lib/files';
-export { migrate } from './lib/migrate';
-export { validateUid } from './lib/uid';
-export { mapToUserFriendlyName, mapToInternalType } from './lib/transform';
-export { getIntermediateRepresentationSchema } from './lib/schemas';
-export { createAjvInstance } from './lib/validation';
-export { ValidateFunction, AnySchema, ErrorObject };
-export { metafileExtension, hsProjectJsonFilename } from './lib/constants';
-export { Components } from './lib/types';
-export { AjvErrorKeyword } from './lib/errors';
-export { getInvalidJsonError, getMissingTypeError, getMissingConfigError, getMissingAccountIdError, getMissingRequiredFieldError, getFailedToFetchSchemasError, getUnsupportedTypeError, } from './lang/copy';

package/src/index.js

@@ -1,86 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getUnsupportedTypeError = exports.getFailedToFetchSchemasError = exports.getMissingRequiredFieldError = exports.getMissingAccountIdError = exports.getMissingConfigError = exports.getMissingTypeError = exports.getInvalidJsonError = exports.AjvErrorKeyword = exports.hsProjectJsonFilename = exports.metafileExtension = exports.createAjvInstance = exports.getIntermediateRepresentationSchema = exports.mapToInternalType = exports.mapToUserFriendlyName = exports.validateUid = exports.migrate = exports.getAllHsProfiles = exports.loadHsProfileFile = exports.getHsProfileFilename = exports.isTranslationError = void 0;
-exports.translate = translate;
-exports.translateForLocalDev = translateForLocalDev;
-const files_1 = require("./lib/files");
-const validation_1 = require("./lib/validation");
-const transform_1 = require("./lib/transform");
-const copy_1 = require("./lang/copy");
-const path_1 = __importDefault(require("path"));
-const defaultOptions = {
-    skipValidation: false,
-};
-async function translate(translationContext, translationOptions = defaultOptions) {
-    const { skipValidation } = translationOptions;
-    const metafileContents = await (0, files_1.loadHsMetaFiles)(translationContext);
-    if (metafileContents.length === 0) {
-        throw new Error(copy_1.errorMessages.project.noHsMetaFiles);
-    }
-    let hsProfileContents;
-    if (translationOptions.profile) {
-        hsProfileContents = (0, files_1.loadHsProfileFile)(translationContext.projectSourceDir, translationOptions.profile);
-    }
-    const transformation = (0, transform_1.transform)(metafileContents, translationContext, hsProfileContents);
-    const intermediateRepresentation = (0, transform_1.getIntermediateRepresentation)(transformation, skipValidation);
-    // Remove once extensions and serverless functions are supported
-    if (!skipValidation) {
-        await (0, validation_1.validateIntermediateRepresentation)(intermediateRepresentation, transformation, translationContext);
-    }
-    return intermediateRepresentation;
-}
-async function translateForLocalDev(translationContext, translationOptions) {
-    const IR = await translate(translationContext, {
-        skipValidation: true,
-        profile: translationOptions?.profile,
-    });
-    const localDevIr = {
-        intermediateNodesIndexedByUid: {},
-    };
-    Object.entries(IR.intermediateNodesIndexedByUid).forEach(([uid, node]) => {
-        const component = IR.intermediateNodesIndexedByUid[uid];
-        const componentConfigPath = path_1.default.join(translationContext.projectSourceDir, component.metaFilePath);
-        localDevIr.intermediateNodesIndexedByUid[uid] = {
-            ...node,
-            localDev: {
-                componentRoot: path_1.default.dirname(componentConfigPath),
-                componentConfigPath,
-            },
-        };
-    });
-    return localDevIr;
-}
-var errors_1 = require("./lib/errors");
-Object.defineProperty(exports, "isTranslationError", { enumerable: true, get: function () { return errors_1.isTranslationError; } });
-var profiles_1 = require("./lib/profiles");
-Object.defineProperty(exports, "getHsProfileFilename", { enumerable: true, get: function () { return profiles_1.getHsProfileFilename; } });
-var files_2 = require("./lib/files");
-Object.defineProperty(exports, "loadHsProfileFile", { enumerable: true, get: function () { return files_2.loadHsProfileFile; } });
-Object.defineProperty(exports, "getAllHsProfiles", { enumerable: true, get: function () { return files_2.getAllHsProfiles; } });
-var migrate_1 = require("./lib/migrate");
-Object.defineProperty(exports, "migrate", { enumerable: true, get: function () { return migrate_1.migrate; } });
-var uid_1 = require("./lib/uid");
-Object.defineProperty(exports, "validateUid", { enumerable: true, get: function () { return uid_1.validateUid; } });
-var transform_2 = require("./lib/transform");
-Object.defineProperty(exports, "mapToUserFriendlyName", { enumerable: true, get: function () { return transform_2.mapToUserFriendlyName; } });
-Object.defineProperty(exports, "mapToInternalType", { enumerable: true, get: function () { return transform_2.mapToInternalType; } });
-var schemas_1 = require("./lib/schemas");
-Object.defineProperty(exports, "getIntermediateRepresentationSchema", { enumerable: true, get: function () { return schemas_1.getIntermediateRepresentationSchema; } });
-var validation_2 = require("./lib/validation");
-Object.defineProperty(exports, "createAjvInstance", { enumerable: true, get: function () { return validation_2.createAjvInstance; } });
-var constants_1 = require("./lib/constants");
-Object.defineProperty(exports, "metafileExtension", { enumerable: true, get: function () { return constants_1.metafileExtension; } });
-Object.defineProperty(exports, "hsProjectJsonFilename", { enumerable: true, get: function () { return constants_1.hsProjectJsonFilename; } });
-var errors_2 = require("./lib/errors");
-Object.defineProperty(exports, "AjvErrorKeyword", { enumerable: true, get: function () { return errors_2.AjvErrorKeyword; } });
-var copy_2 = require("./lang/copy");
-Object.defineProperty(exports, "getInvalidJsonError", { enumerable: true, get: function () { return copy_2.getInvalidJsonError; } });
-Object.defineProperty(exports, "getMissingTypeError", { enumerable: true, get: function () { return copy_2.getMissingTypeError; } });
-Object.defineProperty(exports, "getMissingConfigError", { enumerable: true, get: function () { return copy_2.getMissingConfigError; } });
-Object.defineProperty(exports, "getMissingAccountIdError", { enumerable: true, get: function () { return copy_2.getMissingAccountIdError; } });
-Object.defineProperty(exports, "getMissingRequiredFieldError", { enumerable: true, get: function () { return copy_2.getMissingRequiredFieldError; } });
-Object.defineProperty(exports, "getFailedToFetchSchemasError", { enumerable: true, get: function () { return copy_2.getFailedToFetchSchemasError; } });
-Object.defineProperty(exports, "getUnsupportedTypeError", { enumerable: true, get: function () { return copy_2.getUnsupportedTypeError; } });