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

package/src/lib/validation.js

@@ -1,85 +1,89 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createAjvInstance = createAjvInstance;
-exports.validateIntermediateRepresentation = validateIntermediateRepresentation;
-const schemas_1 = require("./schemas");
-const _2020_1 = __importDefault(require("ajv/dist/2020"));
-const errors_1 = require("./errors");
-const copy_1 = require("../lang/copy");
-const constants_1 = require("./constants");
-const path_1 = __importDefault(require("path"));
-const transform_1 = require("./transform");
-const ajv_formats_1 = __importDefault(require("ajv-formats"));
-const uid_1 = require("./uid");
-function createAjvInstance() {
-    const ajv = new _2020_1.default({ allErrors: true });
-    (0, ajv_formats_1.default)(ajv);
+import { getIntermediateRepresentationSchema } from './schemas.js';
+import { Ajv2020, } from 'ajv/dist/2020.js';
+import { compileError, TranslationError } from './errors.js';
+import { errorMessages } from '../lang/copy.js';
+import { AUTO_GENERATED_COMPONENT_TYPES, Components, PLATFORM_VERSIONS, } from './constants.js';
+import path from 'path';
+import { findTransformationByUid, mapToUserFacingType } from './transform.js';
+import { meetsMinimumPlatformVersion } from './platformVersion.js';
+import { validateUid } from './uid.js';
+// ajv-formats does not play nicely with ESM and TS
+import addFormatsModule from 'ajv-formats';
+const addFormats = addFormatsModule;
+export function createAjvInstance() {
+    const ajv = new Ajv2020({
+        allErrors: true,
+        code: { esm: true },
+        strict: false, // Allow Draft 2020-12 features
+    });
+    addFormats(ajv);
     return ajv;
 }
-function validateIntermediateRepresentationNode(schema, transformation, irNode, index, translationContext) {
-    if (constants_1.AutoGeneratedComponentTypes.includes((0, transform_1.mapToUserFacingType)(irNode.componentType))) {
+function validateIntermediateRepresentationNode(schema, transformation, irNode, translationContext) {
+    if (AUTO_GENERATED_COMPONENT_TYPES.includes(mapToUserFacingType(irNode.componentType))) {
         // Skip validation for auto-generated components
         return {
             valid: true,
         };
     }
-    if (transformation[index].fileParseResult.errors.length > 0) {
+    if (transformation.fileParseResult.errors.length > 0) {
         return {
             valid: false,
-            errors: (0, errors_1.compileError)(transformation[index]),
+            errors: compileError(transformation),
         };
     }
     const ajv = createAjvInstance();
     let shouldSkipValidation = false;
     if (!irNode.uid) {
-        transformation[index].fileParseResult.errors.push(copy_1.errorMessages.validation.missingUid);
+        transformation.fileParseResult.errors.push(errorMessages.validation.missingUid);
     }
     else {
-        const uidValidationResult = (0, uid_1.validateUid)(irNode.uid);
+        const uidValidationResult = validateUid(irNode.uid);
         if (uidValidationResult) {
-            transformation[index].fileParseResult.errors.push(uidValidationResult);
+            transformation.fileParseResult.errors.push(uidValidationResult);
         }
     }
     if (!irNode.config) {
-        transformation[index].fileParseResult.errors.push(copy_1.errorMessages.validation.missingConfig);
+        transformation.fileParseResult.errors.push(errorMessages.validation.missingConfig);
         // If there is no config block, there is nothing to validation
         shouldSkipValidation = true;
     }
+    if (irNode.permissions &&
+        !meetsMinimumPlatformVersion(translationContext.platformVersion, PLATFORM_VERSIONS.v2026_09_BETA)) {
+        transformation.fileParseResult.errors.push(errorMessages.validation.permissionsNotSupported(translationContext.platformVersion));
+    }
     if (!schema[irNode.componentType]) {
         if (!irNode.componentType) {
-            transformation[index].fileParseResult.errors.push(copy_1.errorMessages.validation.missingType);
+            transformation.fileParseResult.errors.push(errorMessages.validation.missingType);
         }
         else {
-            transformation[index].fileParseResult.errors.push(copy_1.errorMessages.validation.unsupportedType(irNode.componentType));
+            transformation.fileParseResult.errors.push(errorMessages.validation.unsupportedType(irNode.componentType));
         }
         // If there is no schema for the component type, there is no way to validate
         shouldSkipValidation = true;
     }
-    const userFacingType = (0, transform_1.mapToUserFacingType)(irNode.componentType);
-    const component = constants_1.Components[userFacingType];
+    const userFacingType = mapToUserFacingType(irNode.componentType);
+    const component = Components[userFacingType];
     if (userFacingType && component) {
         const expectedParentDir = component.parentComponent
-            ? constants_1.Components[component.parentComponent].dir
+            ? Components[component.parentComponent].dir
             : '';
-        const expectedLocation = path_1.default.join(expectedParentDir, component.dir);
-        const actualLocation = path_1.default.dirname(transformation[index].fileParseResult.file);
+        const expectedLocation = path.join(expectedParentDir, component.dir);
+        const actualLocation = path.dirname(transformation.fileParseResult.file);
         if (expectedLocation !== actualLocation) {
-            transformation[index].fileParseResult.errors.push(copy_1.errorMessages.validation.wrongDirectoryForComponent(actualLocation, userFacingType, component, path_1.default.join(translationContext.projectSourceDir, expectedLocation)));
+            transformation.fileParseResult.errors.push(errorMessages.validation.wrongDirectoryForComponent(actualLocation, userFacingType, component, path.join(translationContext.projectSourceDir, expectedLocation)));
         }
     }
     if (shouldSkipValidation) {
         return {
             valid: false,
-            errors: (0, errors_1.compileError)(transformation[index]),
+            errors: compileError(transformation),
         };
     }
     const validate = ajv.compile(schema[irNode.componentType]);
     const valid = validate(irNode.config);
     if (valid) {
-        const { errors } = transformation[index].fileParseResult;
+        const { errors } = transformation.fileParseResult;
         // Even through it passed the schema validation, it may have had other errors along the way
         return errors.length === 0
             ? {
@@ -87,7 +91,7 @@ function validateIntermediateRepresentationNode(schema, transformation, irNode,
             }
             : {
                 valid: false,
-                errors: (0, errors_1.compileError)(transformation[index]),
+                errors: compileError(transformation),
             };
     }
     return {
@@ -95,18 +99,24 @@ function validateIntermediateRepresentationNode(schema, transformation, irNode,
         schemaValidationErrors: validate.errors,
     };
 }
-async function validateIntermediateRepresentation(intermediateRepresentation, transformation, translationContext) {
-    const schema = await (0, schemas_1.getIntermediateRepresentationSchema)(translationContext);
+export async function validateIntermediateRepresentation(intermediateRepresentation, transformations, translationContext) {
+    const hasAnyFileParseErrors = transformations.some(t => t.fileParseResult.errors.length > 0);
+    const schema = await getIntermediateRepresentationSchema(translationContext);
     const potentialDuplicatesByComponent = {};
-    const results = Object.values(intermediateRepresentation.intermediateNodesIndexedByUid).map((irNode, index) => {
-        const userFacingType = (0, transform_1.mapToUserFacingType)(irNode.componentType);
-        const component = constants_1.Components[userFacingType];
+    const results = Object.values(intermediateRepresentation.intermediateNodesIndexedByUid).map(irNode => {
+        const userFacingType = mapToUserFacingType(irNode.componentType);
+        const component = Components[userFacingType];
         if (component && component.singularComponent) {
-            potentialDuplicatesByComponent[userFacingType] = potentialDuplicatesByComponent[userFacingType]
-                ? [...potentialDuplicatesByComponent[userFacingType], irNode]
-                : [irNode];
+            potentialDuplicatesByComponent[userFacingType] =
+                potentialDuplicatesByComponent[userFacingType]
+                    ? [...potentialDuplicatesByComponent[userFacingType], irNode]
+                    : [irNode];
         }
-        return validateIntermediateRepresentationNode(schema, transformation, irNode, index, translationContext);
+        const transformation = findTransformationByUid(transformations, irNode.uid);
+        if (!transformation) {
+            return { valid: false, errors: [errorMessages.validation.missingUid] };
+        }
+        return validateIntermediateRepresentationNode(schema, transformation, irNode, translationContext);
     });
     let hasDuplicates = false;
     Object.entries(potentialDuplicatesByComponent).forEach(([componentType, potentialDuplicates]) => {
@@ -115,17 +125,20 @@ async function validateIntermediateRepresentation(intermediateRepresentation, tr
         }
         hasDuplicates = true;
         potentialDuplicates.forEach(duplicate => {
-            transformation
-                .find(transform => transform.intermediateRepresentation?.uid === duplicate.uid)
-                ?.fileParseResult.errors.push(copy_1.errorMessages.project.duplicateComponent(componentType));
+            const potentialDuplicateTransformation = findTransformationByUid(transformations, duplicate.uid);
+            if (potentialDuplicateTransformation) {
+                potentialDuplicateTransformation.fileParseResult.errors.push(errorMessages.project.duplicateComponent(componentType));
+            }
         });
     });
-    const valid = !hasDuplicates && results.every(result => result.valid);
+    const valid = !hasAnyFileParseErrors &&
+        !hasDuplicates &&
+        results.every(result => result.valid);
     if (valid) {
         return {
             valid,
         };
     }
-    const schemaValidationErrors = results.map(result => result.schemaValidationErrors);
-    throw new errors_1.TranslationError(copy_1.errorMessages.project.failedToTranslateProject, transformation, schemaValidationErrors, translationContext);
+    const schemaValidationErrors = results.map(result => 'schemaValidationErrors' in result ? result.schemaValidationErrors : null);
+    throw new TranslationError(errorMessages.project.failedToTranslateProject, transformations, schemaValidationErrors, translationContext);
 }

package/src/lib/workspaces.d.ts

@@ -0,0 +1,113 @@
+/**
+ * Error thrown when a workspace directory cannot be resolved
+ */
+export declare class WorkspaceResolutionError extends Error {
+    workspaceDir: string;
+    sourcePackageJson: string;
+    constructor(workspaceDir: string, sourcePackageJson: string, cause?: Error);
+}
+/**
+ * Error thrown when a file: dependency cannot be resolved
+ */
+export declare class FileDependencyResolutionError extends Error {
+    packageName: string;
+    dependencyPath: string;
+    sourcePackageJson: string;
+    constructor(packageName: string, dependencyPath: string, sourcePackageJson: string, cause?: Error);
+}
+/**
+ * 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 declare class OrphanWorkspaceProtocolError extends Error {
+    packageName: string;
+    sourcePackageJson: string;
+    constructor(packageName: string, sourcePackageJson: string);
+}
+interface PackageJson {
+    name?: string;
+    workspaces?: string[] | {
+        packages?: string[];
+        nohoist?: string[];
+    };
+    dependencies?: Record<string, string>;
+}
+export interface ParsedPackageJson {
+    path: string;
+    dir: string;
+    content: PackageJson | null;
+}
+export interface WorkspaceMapping {
+    workspaceDir: string;
+    sourcePackageJsonPath: string;
+}
+export type FileDependencyKind = 'directory' | 'tarball';
+export type LocalDependencyProtocol = 'file' | 'link';
+export interface FileDependencyMapping {
+    packageName: string;
+    localPath: string;
+    sourcePackageJsonPath: string;
+    kind: FileDependencyKind;
+    protocol: LocalDependencyProtocol;
+}
+/**
+ * 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 declare function parseLocalSpec(spec: string): {
+    protocol: LocalDependencyProtocol;
+    rawPath: string;
+} | null;
+/**
+ * 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 declare function findAndParsePackageJsonFiles(srcDir: string): Promise<ParsedPackageJson[]>;
+/**
+ * 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 declare function resolveWorkspaceDirectories(baseDir: string, workspaceGlobs: string[]): Promise<string[]>;
+/**
+ * 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 declare function collectWorkspaceDirectories(parsedPackageJsons: ParsedPackageJson[]): Promise<WorkspaceMapping[]>;
+/**
+ * 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 declare function collectFileDependencies(parsedPackageJsons: ParsedPackageJson[]): Promise<FileDependencyMapping[]>;
+/**
+ * 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 declare function validateWorkspaceProtocolDependencies(parsedPackageJsons: ParsedPackageJson[], workspaceMappings: WorkspaceMapping[]): void;
+/**
+ * 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 declare function getPackableFiles(dir: string): Promise<Set<string>>;
+export {};