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

package/src/lib/types.d.ts

@@ -1,10 +1,16 @@
-import { ErrorObject } from 'ajv/dist/2020';
+import type { ErrorObject } from 'ajv';
 export type Dependencies = Record<string, string | string[]>;
-export interface Components {
+export interface ComponentPermissions {
+    requiredScopes?: string[];
+    optionalScopes?: string[];
+    conditionallyRequiredScopes?: string[];
+}
+export interface ComponentMeta {
     uid: string;
     type: string;
     config: unknown;
     dependencies?: Dependencies;
+    permissions?: ComponentPermissions;
 }
 export interface FileActionResult {
     file: string;
@@ -15,7 +21,7 @@ export interface FileLoadResult extends FileActionResult {
     content?: string;
 }
 export interface FileParseResult extends FileActionResult {
-    content?: Components;
+    content?: ComponentMeta;
 }
 export interface IntermediateRepresentationNode {
     componentType: string;
@@ -24,22 +30,39 @@ export interface IntermediateRepresentationNode {
     uid: string;
     config: unknown;
     files: unknown;
+    permissions?: ComponentPermissions;
+}
+export type BEProfileVariableType = 'PROFILE_INT' | 'PROFILE_LONG' | 'PROFILE_STRING' | 'PROFILE_BOOLEAN';
+export interface BEProfileVariables {
+    [key: string]: {
+        variableType: BEProfileVariableType;
+        value: HSProfileVariableType;
+    };
 }
 export interface IntermediateRepresentation {
     intermediateNodesIndexedByUid: {
         [key: string]: IntermediateRepresentationNode;
     };
+    profileData?: {
+        vars: {
+            profileVariables: BEProfileVariables;
+        };
+    };
 }
 export interface IntermediateRepresentationNodeLocalDev extends IntermediateRepresentationNode {
     localDev: {
         componentRoot: string;
         componentConfigPath: string;
+        configUpdatedSinceLastUpload: boolean;
+        removed: boolean;
+        parsingErrors: string[];
     };
 }
 export interface IntermediateRepresentationLocalDev {
     intermediateNodesIndexedByUid: {
         [key: string]: IntermediateRepresentationNodeLocalDev;
     };
+    profileData: HSProfileVariables;
 }
 export type Transformation = {
     intermediateRepresentation?: IntermediateRepresentationNode | null;
@@ -58,9 +81,17 @@ export interface TranslationOptions {
     skipValidation?: boolean;
     profile?: string;
 }
+export interface TranslationOptionsLocalDev extends TranslationOptions {
+    projectNodesAtLastUpload?: {
+        [key: string]: IntermediateRepresentationNodeLocalDev;
+    };
+}
+type HSProfileVariableType = string | number | boolean;
+export type HSProfileVariables = {
+    [key: string]: HSProfileVariableType;
+};
 export interface HsProfileFile {
     accountId: number;
-    variables?: {
-        [key: string]: string | number | boolean;
-    };
+    variables?: HSProfileVariables;
 }
+export {};

package/src/lib/types.js

@@ -1,2 +1 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
+export {};

package/src/lib/uid.d.ts

@@ -1 +1,3 @@
+export declare const MAX_UID_LENGTH = 64;
 export declare function validateUid(uid: string): string | undefined;
+export declare function coerceToValidUid(potentialUid: string): string | undefined;

package/src/lib/uid.js

@@ -1,15 +1,20 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.validateUid = validateUid;
-const copy_1 = require("../lang/copy");
-function validateUid(uid) {
+import { errorMessages } from '../lang/copy.js';
+export const MAX_UID_LENGTH = 64;
+export function validateUid(uid) {
     if (uid === '' || !uid) {
-        return copy_1.errorMessages.validation.emptyUid;
+        return errorMessages.validation.emptyUid;
     }
-    if (uid.length > 64) {
-        return copy_1.errorMessages.validation.uidTooLong;
+    if (uid.length > MAX_UID_LENGTH) {
+        return errorMessages.validation.uidTooLong;
     }
     if (!/^[a-zA-Z0-9_\-.]+$/.test(uid)) {
-        return copy_1.errorMessages.validation.invalidUid;
+        return errorMessages.validation.invalidUid;
     }
 }
+export function coerceToValidUid(potentialUid) {
+    if (typeof potentialUid !== 'string') {
+        return undefined;
+    }
+    const newUid = potentialUid.replace(/[^a-zA-Z0-9_\-.]/g, '');
+    return newUid.length === 0 ? undefined : newUid.substring(0, MAX_UID_LENGTH);
+}

package/src/lib/utils.d.ts

@@ -0,0 +1,3 @@
+import { BEProfileVariableType } from './types.js';
+export declare function loadJsonFile(filename: string): any;
+export declare function getJavaNumberType(value: number): BEProfileVariableType;

package/src/lib/utils.js

@@ -0,0 +1,16 @@
+import fs from 'fs';
+import { PROFILE_VARIABLE_TYPES } from './constants.js';
+export function loadJsonFile(filename) {
+    return JSON.parse(fs.readFileSync(filename, {
+        encoding: 'utf-8',
+    }));
+}
+export function getJavaNumberType(value) {
+    const JAVA_INT_MIN = -2_147_483_648;
+    const JAVA_INT_MAX = 2_147_483_647;
+    // Check if the value fits in Java int range
+    if (value >= JAVA_INT_MIN && value <= JAVA_INT_MAX) {
+        return PROFILE_VARIABLE_TYPES.PROFILE_INT;
+    }
+    return PROFILE_VARIABLE_TYPES.PROFILE_LONG;
+}

package/src/lib/validation.d.ts

@@ -1,5 +1,5 @@
-import { CompiledError, IntermediateRepresentation, Transformation, TranslationContext } from './types';
-import Ajv, { ValidateFunction } from 'ajv/dist/2020';
+import { CompiledError, IntermediateRepresentation, Transformation, TranslationContext } from './types.js';
+import { Ajv2020, ValidateFunction } from 'ajv/dist/2020.js';
 export type ValidResult = {
     valid: true;
     errors?: null;
@@ -10,5 +10,5 @@ export type ValidationResults = {
     errors?: CompiledError;
     schemaValidationErrors?: ValidateFunction['errors'];
 } | ValidResult;
-export declare function createAjvInstance(): Ajv;
-export declare function validateIntermediateRepresentation(intermediateRepresentation: IntermediateRepresentation, transformation: Transformation[], translationContext: TranslationContext): Promise<ValidResult>;
+export declare function createAjvInstance(): Ajv2020;
+export declare function validateIntermediateRepresentation(intermediateRepresentation: IntermediateRepresentation, transformations: Transformation[], translationContext: TranslationContext): Promise<ValidResult>;

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 } from './constants.js';
+import path from 'path';
+import { findTransformationByUid, mapToUserFacingType } from './transform.js';
+import { supportsComponentPermissions } 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 &&
+        !supportsComponentPermissions(translationContext.platformVersion)) {
+        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 {};