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

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/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; } });