@hubspot/project-parsing-lib 0.2.2-beta.0 → 0.2.2-experimental.0

package/src/lib/workspaces.js

@@ -0,0 +1,403 @@
+import fs from 'fs';
+import fsPromises from 'fs/promises';
+import path from 'path';
+import os from 'os';
+import { fileURLToPath } from 'node:url';
+import mapWorkspaces from '@npmcli/map-workspaces';
+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;
+        }
+    }
+}
+/**
+ * Error thrown when a `workspace:` protocol dependency does not match any known
+ * workspace member. npm itself does not support the `workspace:` protocol —
+ * only pnpm and yarn berry do — so the install fails with a confusing message
+ * server-side. Surface a clearer error up front.
+ */
+export class OrphanWorkspaceProtocolError extends Error {
+    packageName;
+    sourcePackageJson;
+    constructor(packageName, sourcePackageJson) {
+        super(`Found \`workspace:\` protocol dependency "${packageName}" in ${sourcePackageJson} but no workspace member is named "${packageName}". ` +
+            `The \`workspace:\` protocol requires a matching workspace member declared under "workspaces" in a parent package.json. ` +
+            `If you're migrating from pnpm or yarn berry, replace with \`file:./<relative-path>\` or \`link:./<relative-path>\`, or add the package under "workspaces".`);
+        this.packageName = packageName;
+        this.sourcePackageJson = sourcePackageJson;
+        this.name = 'OrphanWorkspaceProtocolError';
+    }
+}
+const TARBALL_EXTENSIONS = ['.tgz', '.tar.gz', '.tar'];
+function hasTarballExtension(p) {
+    const lower = p.toLowerCase();
+    return TARBALL_EXTENSIONS.some(ext => lower.endsWith(ext));
+}
+/**
+ * Expands tilde (~) in paths to the user's home directory
+ */
+function expandTildePath(filePath) {
+    return filePath.startsWith('~')
+        ? path.join(os.homedir(), filePath.slice(1))
+        : filePath;
+}
+/**
+ * Parses a `file:` or `link:` dependency spec into its protocol and raw path.
+ * Handles all npm-supported shapes:
+ *   - file:./relative/path
+ *   - file:relative/path (no leading slash/dot)
+ *   - file:/absolute/path
+ *   - file://./relative — npm-style file URL with relative path
+ *   - file:///absolute — file URL with absolute path
+ *   - link:./relative/path (symlink semantics for directories only)
+ */
+export function parseLocalSpec(spec) {
+    const match = /^(file|link):(.*)$/.exec(spec);
+    if (!match) {
+        return null;
+    }
+    const protocol = match[1];
+    let rawPath = match[2];
+    if (rawPath.startsWith('//')) {
+        try {
+            rawPath = fileURLToPath(`file:${rawPath}`);
+        }
+        catch {
+            return { protocol, rawPath };
+        }
+    }
+    return { protocol, rawPath };
+}
+/**
+ * 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 [];
+    }
+    if (Array.isArray(workspaces)) {
+        return workspaces;
+    }
+    if (workspaces.packages && Array.isArray(workspaces.packages)) {
+        return workspaces.packages;
+    }
+    return [];
+}
+/**
+ * Resolves workspace glob patterns to actual directories.
+ *
+ * Uses @npmcli/map-workspaces (npm's reference impl) so that negation patterns
+ * like `["packages/*", "!packages/excluded"]` are honored — a hand-rolled
+ * per-pattern glob() silently accepted negations without actually excluding.
+ */
+export async function resolveWorkspaceDirectories(baseDir, workspaceGlobs) {
+    if (workspaceGlobs.length === 0) {
+        return [];
+    }
+    const expandedGlobs = workspaceGlobs.map(expandTildePath);
+    let workspaceMap;
+    try {
+        workspaceMap = await mapWorkspaces({
+            pkg: { workspaces: expandedGlobs },
+            cwd: baseDir,
+        });
+    }
+    catch (e) {
+        logger.debug(`Failed to resolve workspace patterns in ${baseDir} via map-workspaces: ${e}`);
+        return [];
+    }
+    const resolved = new Set();
+    for (const dir of workspaceMap.values()) {
+        try {
+            const stats = await fsPromises.stat(dir);
+            if (!stats.isDirectory()) {
+                continue;
+            }
+            const packageJsonPath = path.join(dir, 'package.json');
+            try {
+                await fsPromises.access(packageJsonPath, fs.constants.F_OK);
+                resolved.add(dir);
+            }
+            catch {
+                // Directory exists but doesn't contain package.json — skip silently.
+            }
+        }
+        catch (e) {
+            logger.warn(`Cannot access directory ${dir}: ${e}`);
+        }
+    }
+    return Array.from(resolved);
+}
+/**
+ * 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. Both keys use realpath
+    // form so case-only differences on case-insensitive filesystems collapse.
+    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);
+        let sourceRealPath;
+        try {
+            sourceRealPath = await fsPromises.realpath(parsed.path);
+        }
+        catch {
+            sourceRealPath = parsed.path;
+        }
+        for (const dir of resolved) {
+            let realDir;
+            try {
+                realDir = await fsPromises.realpath(dir);
+            }
+            catch (e) {
+                throw new WorkspaceResolutionError(dir, parsed.path, e instanceof Error ? e : undefined);
+            }
+            const pairKey = `${sourceRealPath}::${realDir}`;
+            if (visited.has(pairKey)) {
+                logger.debug(`Skipping duplicate workspace mapping: ${realDir} from ${parsed.path}`);
+                continue;
+            }
+            visited.add(pairKey);
+            workspaceMappings.push({
+                workspaceDir: realDir,
+                sourcePackageJsonPath: parsed.path,
+            });
+            logger.debug(`Resolved workspace: ${realDir}`);
+        }
+    }
+    return workspaceMappings;
+}
+/**
+ * Extracts file: and link: 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)) {
+        if (typeof version !== 'string') {
+            continue;
+        }
+        const parsed = parseLocalSpec(version);
+        if (parsed) {
+            fileDeps.push({
+                packageName,
+                protocol: parsed.protocol,
+                rawPath: parsed.rawPath,
+            });
+        }
+    }
+    return fileDeps;
+}
+/**
+ * Collects all `file:` and `link:` dependencies that need to be uploaded.
+ * Returns mappings that track the package name, resolved path, source
+ * package.json, kind (directory vs tarball) and protocol (file vs link).
+ */
+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:/link: dependencies in ${parsed.path}: ${fileDeps.map(d => d.packageName).join(', ')}`);
+        for (const { packageName, protocol, rawPath } of fileDeps) {
+            const expandedPath = expandTildePath(rawPath);
+            const absolutePath = path.resolve(parsed.dir, expandedPath);
+            const looksLikeTarball = hasTarballExtension(absolutePath);
+            if (looksLikeTarball && protocol === 'link') {
+                throw new FileDependencyResolutionError(packageName, absolutePath, parsed.path, new Error('`link:` protocol is for directories (symlink semantics); use `file:` for tarballs'));
+            }
+            let realPath;
+            try {
+                realPath = await fsPromises.realpath(absolutePath);
+            }
+            catch (e) {
+                throw new FileDependencyResolutionError(packageName, absolutePath, parsed.path, e instanceof Error ? e : undefined);
+            }
+            let stats;
+            try {
+                stats = await fsPromises.stat(realPath);
+            }
+            catch (e) {
+                throw new FileDependencyResolutionError(packageName, realPath, parsed.path, e instanceof Error ? e : undefined);
+            }
+            let kind;
+            if (looksLikeTarball) {
+                if (!stats.isFile()) {
+                    throw new FileDependencyResolutionError(packageName, realPath, parsed.path, new Error('Tarball path is not a regular file'));
+                }
+                kind = 'tarball';
+            }
+            else if (stats.isDirectory()) {
+                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'));
+                }
+                kind = 'directory';
+            }
+            else {
+                throw new FileDependencyResolutionError(packageName, realPath, parsed.path, new Error('Path is not a directory'));
+            }
+            if (visited.has(realPath)) {
+                logger.debug(`Skipping already visited file: dependency: ${realPath}`);
+                continue;
+            }
+            visited.add(realPath);
+            fileDependencyMappings.push({
+                packageName,
+                localPath: realPath,
+                sourcePackageJsonPath: parsed.path,
+                kind,
+                protocol,
+            });
+            logger.debug(`Resolved ${protocol}: dependency ${packageName} (${kind}): ${realPath}`);
+        }
+    }
+    return fileDependencyMappings;
+}
+/**
+ * Validates that every `workspace:` protocol dependency in the parsed package
+ * trees matches a known workspace member. Throws OrphanWorkspaceProtocolError
+ * for the first orphan found.
+ *
+ * npm itself does not implement the `workspace:` protocol; only pnpm and yarn
+ * berry do. If a project uses `workspace:*` without a matching member declared
+ * under `workspaces`, the install fails server-side with a confusing message —
+ * fail fast with a clearer one.
+ */
+export function validateWorkspaceProtocolDependencies(parsedPackageJsons, workspaceMappings) {
+    const workspacePackageNames = new Set();
+    const workspaceDirs = new Set(workspaceMappings.map(m => m.workspaceDir));
+    for (const parsed of parsedPackageJsons) {
+        if (!parsed.content?.name) {
+            continue;
+        }
+        let realDir;
+        try {
+            realDir = fs.realpathSync(parsed.dir);
+        }
+        catch {
+            continue;
+        }
+        if (workspaceDirs.has(realDir)) {
+            workspacePackageNames.add(parsed.content.name);
+        }
+    }
+    for (const parsed of parsedPackageJsons) {
+        const deps = parsed.content?.dependencies;
+        if (!deps) {
+            continue;
+        }
+        for (const [packageName, version] of Object.entries(deps)) {
+            if (typeof version !== 'string' || !version.startsWith('workspace:')) {
+                continue;
+            }
+            if (!workspacePackageNames.has(packageName)) {
+                throw new OrphanWorkspaceProtocolError(packageName, parsed.path);
+            }
+        }
+    }
+}
+/**
+ * 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);
+        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, projectContainsHsMetaFiles, } 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,87 +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.projectContainsHsMetaFiles = 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; } });
-Object.defineProperty(exports, "projectContainsHsMetaFiles", { enumerable: true, get: function () { return files_2.projectContainsHsMetaFiles; } });
-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; } });