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

package/src/lib/types.d.ts

@@ -1,6 +1,6 @@
-import { ErrorObject } from 'ajv/dist/2020';
+import type { ErrorObject } from 'ajv';
 export type Dependencies = Record<string, string | string[]>;
-export interface Components {
+export interface ComponentMeta {
     uid: string;
     type: string;
     config: unknown;
@@ -15,7 +15,7 @@ export interface FileLoadResult extends FileActionResult {
     content?: string;
 }
 export interface FileParseResult extends FileActionResult {
-    content?: Components;
+    content?: ComponentMeta;
 }
 export interface IntermediateRepresentationNode {
     componentType: string;
@@ -25,21 +25,37 @@ export interface IntermediateRepresentationNode {
     config: unknown;
     files: unknown;
 }
+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 +74,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,84 @@
-"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 { 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 (!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 +86,7 @@ function validateIntermediateRepresentationNode(schema, transformation, irNode,
             }
             : {
                 valid: false,
-                errors: (0, errors_1.compileError)(transformation[index]),
+                errors: compileError(transformation),
             };
     }
     return {
@@ -95,18 +94,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];
+        }
+        const transformation = findTransformationByUid(transformations, irNode.uid);
+        if (!transformation) {
+            return { valid: false, errors: [errorMessages.validation.missingUid] };
         }
-        return validateIntermediateRepresentationNode(schema, transformation, irNode, index, translationContext);
+        return validateIntermediateRepresentationNode(schema, transformation, irNode, translationContext);
     });
     let hasDuplicates = false;
     Object.entries(potentialDuplicatesByComponent).forEach(([componentType, potentialDuplicates]) => {
@@ -115,17 +120,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,68 @@
+/**
+ * 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);
+}
+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 interface FileDependencyMapping {
+    packageName: string;
+    localPath: string;
+    sourcePackageJsonPath: string;
+}
+/**
+ * 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
+ */
+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: dependencies that need to be uploaded.
+ * Returns mappings that track the package name, resolved path, and source package.json.
+ */
+export declare function collectFileDependencies(parsedPackageJsons: ParsedPackageJson[]): Promise<FileDependencyMapping[]>;
+/**
+ * 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 {};