@hubspot/project-parsing-lib 0.3.2 → 0.4.0-experimental.0

package/src/lib/transform.js

@@ -1,81 +1,80 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.mapToInternalType = mapToInternalType;
-exports.mapToUserFacingType = mapToUserFacingType;
-exports.mapToUserFriendlyName = mapToUserFriendlyName;
-exports.transform = transform;
-exports.getIntermediateRepresentation = getIntermediateRepresentation;
-exports.generateServerlessPackageComponent = generateServerlessPackageComponent;
-const profiles_1 = require("./profiles");
-const constants_1 = require("./constants");
-const copy_1 = require("../lang/copy");
-const path_1 = __importDefault(require("path"));
-const fs_1 = __importDefault(require("fs"));
-const logger_1 = require("@hubspot/local-dev-lib/logger");
+import path from 'path';
+import fs from 'fs';
+import { logger } from '@hubspot/local-dev-lib/logger';
+import { applyHsProfileVariables, getHsProfileVariables } from './profiles.js';
+import { APP_KEY, APP_OBJECT_KEY, Components, PROJECT_STRUCTURE, APP_FUNCTIONS_KEY, APP_FUNCTIONS_PACKAGE_KEY, USER_FACING_TO_INTERNAL_TYPE, INTERNAL_TYPE_TO_USER_FACING, PACKAGE_JSON, PACKAGE_LOCK_JSON, PROFILE_VARIABLE_TYPES, } from './constants.js';
+import { errorMessages } from '../lang/copy.js';
+import { getJavaNumberType } from './utils.js';
+import { convertPathToPosixPath } from './files.js';
 function calculateComponentDeps(fileValidationResult, parentComponents, appObjects, appFunctionsPackageUid) {
-    let dependencies = {};
-    // If there are dependencies in the config file, pass them through
-    if (!fileValidationResult.content?.dependencies) {
-        dependencies = { ...fileValidationResult.content?.dependencies };
-    }
+    // Pass through any developer-authored dependencies declared in the hsmeta
+    // file. Framework-injected structural dependencies (app, allAppObjects,
+    // serverlessPackage) are layered on top below and take precedence over any
+    // authored value for those reserved keys.
+    const dependencies = {
+        ...fileValidationResult.content?.dependencies,
+    };
     const { type } = fileValidationResult.content;
     // If the component is a child of the App component, add the app and appObjects as dependencies
-    if (constants_1.Components[type]?.parentComponent === constants_1.AppKey) {
-        const parentUid = parentComponents[constants_1.AppKey];
+    if (Components[type]?.parentComponent === APP_KEY) {
+        const parentUid = parentComponents[APP_KEY];
         if (parentUid) {
             dependencies.app = parentUid;
         }
         else {
-            logger_1.logger.debug(parentComponents);
-            throw new Error(copy_1.errorMessages.project.mustHaveAppComponent(type));
+            logger.debug(parentComponents);
+            return {
+                dependencies,
+                errors: [errorMessages.project.mustHaveAppComponent(type)],
+            };
         }
-        if (type !== constants_1.AppObjectKey) {
+        if (type !== APP_OBJECT_KEY) {
             dependencies.allAppObjects = appObjects;
         }
-        if (type === constants_1.AppFunctionsKey && appFunctionsPackageUid) {
+        if (type === APP_FUNCTIONS_KEY && appFunctionsPackageUid) {
             dependencies.serverlessPackage = appFunctionsPackageUid;
         }
     }
-    return dependencies;
+    return { dependencies };
 }
-function mapToInternalType(type) {
-    const resolvedType = constants_1.userFacingToInternalType[type] || type || '';
+export function mapToInternalType(type) {
+    const resolvedType = USER_FACING_TO_INTERNAL_TYPE[type] || type || '';
     return resolvedType.toUpperCase().replace(/-/g, '_');
 }
-function mapToUserFacingType(type) {
-    return (constants_1.internalTypeToUserFacing[type] || type || '')
+export function mapToUserFacingType(type) {
+    return (INTERNAL_TYPE_TO_USER_FACING[type] || type || '')
         .toLowerCase()
         .replace(/_/g, '-');
 }
-function mapToUserFriendlyName(internalType) {
-    return constants_1.Components[mapToUserFacingType(internalType)]?.userFriendlyName || '';
+export function mapToUserFriendlyName(internalType) {
+    return Components[mapToUserFacingType(internalType)]?.userFriendlyName || '';
 }
-function transform(fileParseResults, translationContext, hsProfileContents) {
-    const parentTypes = Object.keys(constants_1.ProjectStructure);
+export function findTransformationByUid(transformations, uid) {
+    return transformations.find(t => t.intermediateRepresentation?.uid === uid);
+}
+export function transform(fileParseResults, translationContext, hsProfileContents) {
+    const parentTypes = Object.keys(PROJECT_STRUCTURE);
     const parentComponents = {};
     const allAppObjects = [];
     let appUid = '';
     let appFunctionsDirectory;
     // Apply the profile variable overrides to the config
     if (hsProfileContents) {
-        fileParseResults = (0, profiles_1.applyHsProfileVariables)(fileParseResults, hsProfileContents);
+        fileParseResults = applyHsProfileVariables(fileParseResults, hsProfileContents);
     }
     // Compute the parent components, so we can add them as dependencies to the child components
     fileParseResults.forEach(file => {
         if (file.content?.type && parentTypes.includes(file.content.type)) {
-            if (file.content.type === constants_1.AppKey) {
+            if (file.content.type === APP_KEY) {
                 appUid = file.content.uid;
             }
             parentComponents[file.content.type] = file.content.uid;
         }
-        if (file.content?.type === constants_1.AppObjectKey) {
+        if (file.content?.type === APP_OBJECT_KEY) {
             allAppObjects.push(file.content.uid);
         }
-        if (file.content?.type === constants_1.AppFunctionsKey) {
-            appFunctionsDirectory = path_1.default.dirname(file.file);
+        if (file.content?.type === APP_FUNCTIONS_KEY) {
+            appFunctionsDirectory = path.dirname(file.file);
         }
     });
     const autoGeneratedComponents = [];
@@ -90,28 +89,35 @@ function transform(fileParseResults, translationContext, hsProfileContents) {
     }
     const transformations = fileParseResults.map((currentFile) => {
         if (!currentFile.content) {
-            currentFile.errors?.push(copy_1.errorMessages.project.fileContentMissingFor(currentFile.file));
+            if (!currentFile.errors?.includes(errorMessages.validation.invalidJson)) {
+                currentFile.errors?.push(errorMessages.project.fileContentMissingFor(currentFile.file));
+            }
             return {
                 intermediateRepresentation: null,
                 fileParseResult: currentFile,
             };
         }
-        const { config, uid, type } = currentFile.content;
+        const { config, uid, type, permissions } = currentFile.content;
+        const { dependencies, errors } = calculateComponentDeps(currentFile, parentComponents, allAppObjects, serverlessPackageUid);
+        if (errors) {
+            currentFile.errors?.push(...errors);
+        }
         return {
             intermediateRepresentation: {
                 uid,
                 config,
                 componentType: mapToInternalType(type),
-                componentDeps: calculateComponentDeps(currentFile, parentComponents, allAppObjects, serverlessPackageUid),
-                metaFilePath: currentFile.file,
+                componentDeps: dependencies,
+                metaFilePath: convertPathToPosixPath(currentFile.file),
                 files: {},
+                ...(permissions ? { permissions } : {}),
             },
             fileParseResult: currentFile,
         };
     });
     return [...autoGeneratedComponents, ...transformations];
 }
-function getIntermediateRepresentation(transformations, skipValidation) {
+export function getIntermediateRepresentation(transformations, hsProfileContents, skipValidation) {
     const nodes = transformations.reduce((acc, current) => {
         if (!current.intermediateRepresentation) {
             return acc;
@@ -121,15 +127,14 @@ function getIntermediateRepresentation(transformations, skipValidation) {
             const duplicates = transformations
                 .filter(t => t.intermediateRepresentation?.uid === uid)
                 .map(t => t.fileParseResult.file);
-            throw new Error(copy_1.errorMessages.project.duplicateUid(uid, duplicates));
+            throw new Error(errorMessages.project.duplicateUid(uid, duplicates));
         }
         if (!skipValidation) {
             return {
                 ...acc,
                 // If the uid is not defined just make one up for the sake of indexing.
                 // It will still fail validation, but this prevents collisions so we validate all files.
-                [uid ||
-                    `missing-${current.fileParseResult.file}`]: current.intermediateRepresentation,
+                [uid || `missing-${current.fileParseResult.file}`]: current.intermediateRepresentation,
             };
         }
         return {
@@ -137,17 +142,55 @@ function getIntermediateRepresentation(transformations, skipValidation) {
             [uid]: current.intermediateRepresentation,
         };
     }, {});
+    const profileData = getProfileData(hsProfileContents);
     return {
         intermediateNodesIndexedByUid: nodes,
+        profileData,
     };
 }
-function generateServerlessPackageComponent(appFunctionsDirectory, translationContext, componentDeps) {
-    const packageFile = path_1.default.join(appFunctionsDirectory, constants_1.packageJson);
-    const packageLockFile = path_1.default.join(appFunctionsDirectory, constants_1.packageLockJson);
-    const { projectSourceDir } = translationContext;
-    const appFunctionsPackageFile = path_1.default.join(projectSourceDir, packageFile);
-    if (!fs_1.default.existsSync(appFunctionsPackageFile)) {
-        throw new Error(copy_1.errorMessages.project.noPackageJsonForServerless(appFunctionsPackageFile));
+export function getParsingErrors(transformations) {
+    return transformations
+        .filter(t => t.fileParseResult.errors.length > 0)
+        .map(t => t.fileParseResult);
+}
+function getProfileData(hsProfileContents) {
+    const profileVariablesForBE = {};
+    if (hsProfileContents && hsProfileContents.variables) {
+        const profileVariables = getHsProfileVariables(hsProfileContents);
+        Object.keys(profileVariables).forEach(key => {
+            const profileVar = profileVariables[key];
+            let variableTypeForBE;
+            switch (typeof profileVar) {
+                case 'string':
+                    variableTypeForBE = PROFILE_VARIABLE_TYPES.PROFILE_STRING;
+                    break;
+                case 'number':
+                    variableTypeForBE = getJavaNumberType(profileVar);
+                    break;
+                case 'boolean':
+                    variableTypeForBE = PROFILE_VARIABLE_TYPES.PROFILE_BOOLEAN;
+                    break;
+                default:
+                    break;
+            }
+            if (variableTypeForBE) {
+                profileVariablesForBE[key] = {
+                    variableType: variableTypeForBE,
+                    value: profileVar,
+                };
+            }
+        });
+    }
+    return { vars: { profileVariables: profileVariablesForBE } };
+}
+export function generateServerlessPackageComponent(appFunctionsDirectory, translationContext, componentDeps) {
+    const appFunctionsPosix = convertPathToPosixPath(appFunctionsDirectory);
+    const packageFilePosix = path.posix.join(appFunctionsPosix, PACKAGE_JSON);
+    const packageLockFilePosix = path.posix.join(appFunctionsPosix, PACKAGE_LOCK_JSON);
+    const projectSourceDirPosix = convertPathToPosixPath(translationContext.projectSourceDir);
+    const appFunctionsPackageFile = path.posix.join(projectSourceDirPosix, packageFilePosix);
+    if (!fs.existsSync(appFunctionsPackageFile)) {
+        throw new Error(errorMessages.project.noPackageJsonForServerless(appFunctionsPackageFile));
     }
     const uid = `hubspot-serverless-package-uid`;
     return {
@@ -159,15 +202,17 @@ function generateServerlessPackageComponent(appFunctionsDirectory, translationCo
             },
             intermediateRepresentation: {
                 uid,
-                componentType: mapToInternalType(constants_1.AppFunctionsPackageKey),
+                componentType: mapToInternalType(APP_FUNCTIONS_PACKAGE_KEY),
                 config: {
-                    packageFile,
-                    packageLockfile: fs_1.default.existsSync(path_1.default.join(projectSourceDir, packageLockFile))
-                        ? packageLockFile
+                    packageFile: packageFilePosix,
+                    packageLockfile: fs.existsSync(
+                    // Don't use posix here because we are checking the file system
+                    path.join(translationContext.projectSourceDir, path.join(appFunctionsDirectory, PACKAGE_LOCK_JSON)))
+                        ? packageLockFilePosix
                         : undefined,
                 },
                 componentDeps,
-                metaFilePath: packageFile,
+                metaFilePath: packageFilePosix,
                 files: {},
             },
         },

package/src/lib/translate.d.ts

@@ -0,0 +1,11 @@
+import { IntermediateRepresentation, IntermediateRepresentationLocalDev, TranslationContext, TranslationOptions, TranslationOptionsLocalDev } from './types.js';
+export interface TranslateResult {
+    intermediateRepresentation: IntermediateRepresentation;
+    skippedHsMetaFiles: string[];
+}
+export interface TranslateForLocalDevResult {
+    intermediateRepresentation: IntermediateRepresentationLocalDev;
+    skippedHsMetaFiles: string[];
+}
+export declare function translate(translationContext: TranslationContext, translationOptions?: TranslationOptions): Promise<TranslateResult>;
+export declare function translateForLocalDev(translationContext: TranslationContext, translationOptions?: TranslationOptionsLocalDev): Promise<TranslateForLocalDevResult>;

package/src/lib/translate.js

@@ -0,0 +1,65 @@
+import { loadHsProfileFile, loadHsMetaFiles } from './files.js';
+import { validateIntermediateRepresentation } from './validation.js';
+import { getIntermediateRepresentation, getParsingErrors, transform, } from './transform.js';
+import { errorMessages } from '../lang/copy.js';
+import { getLocalDevProfileData, getLocalDevProjectNodes, getRemovedNodesAndNodesWithErrors, } from './localDev.js';
+import { isKnownPlatformVersion } from './platformVersion.js';
+const defaultOptions = {
+    skipValidation: false,
+};
+export async function translate(translationContext, translationOptions = defaultOptions) {
+    const { skipValidation, profile } = translationOptions;
+    if (!skipValidation &&
+        !isKnownPlatformVersion(translationContext.platformVersion)) {
+        throw new Error(errorMessages.project.unsupportedPlatformVersion(translationContext.platformVersion));
+    }
+    const { results: metafileContents, skippedFiles } = await loadHsMetaFiles(translationContext);
+    if (metafileContents.length === 0) {
+        throw new Error(errorMessages.project.noHsMetaFiles);
+    }
+    let hsProfileContents;
+    if (profile) {
+        hsProfileContents = loadHsProfileFile(translationContext.projectSourceDir, profile);
+    }
+    const transformations = transform(metafileContents, translationContext, hsProfileContents);
+    const intermediateRepresentation = getIntermediateRepresentation(transformations, hsProfileContents, skipValidation);
+    // Remove once extensions and serverless functions are supported
+    if (!skipValidation) {
+        await validateIntermediateRepresentation(intermediateRepresentation, transformations, translationContext);
+    }
+    return { intermediateRepresentation, skippedHsMetaFiles: skippedFiles };
+}
+export async function translateForLocalDev(translationContext, translationOptions) {
+    const { skipValidation, profile, projectNodesAtLastUpload } = translationOptions || {};
+    if (!skipValidation &&
+        !isKnownPlatformVersion(translationContext.platformVersion)) {
+        throw new Error(errorMessages.project.unsupportedPlatformVersion(translationContext.platformVersion));
+    }
+    const { results: metafileContents, skippedFiles } = await loadHsMetaFiles(translationContext);
+    if (metafileContents.length === 0) {
+        throw new Error(errorMessages.project.noHsMetaFiles);
+    }
+    let hsProfileContents;
+    if (profile) {
+        hsProfileContents = loadHsProfileFile(translationContext.projectSourceDir, profile);
+    }
+    const transformation = transform(metafileContents, translationContext, hsProfileContents);
+    const baseIntermediateRepresentation = getIntermediateRepresentation(transformation, hsProfileContents, true);
+    const parsingErrors = getParsingErrors(transformation);
+    const projectNodes = getLocalDevProjectNodes(baseIntermediateRepresentation.intermediateNodesIndexedByUid, translationContext.projectSourceDir, projectNodesAtLastUpload);
+    let projectNodesWithErrors = {};
+    if (projectNodesAtLastUpload) {
+        projectNodesWithErrors = getRemovedNodesAndNodesWithErrors(baseIntermediateRepresentation.intermediateNodesIndexedByUid, projectNodesAtLastUpload, parsingErrors);
+    }
+    const profileData = getLocalDevProfileData(baseIntermediateRepresentation.profileData?.vars.profileVariables);
+    return {
+        intermediateRepresentation: {
+            intermediateNodesIndexedByUid: {
+                ...projectNodes,
+                ...projectNodesWithErrors,
+            },
+            profileData,
+        },
+        skippedHsMetaFiles: skippedFiles,
+    };
+}

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,23 +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;
@@ -50,6 +72,12 @@ export type Transformation = {
 export type CompiledError = {
     errors: string[];
 };
+export interface ProjectConfig {
+    name: string;
+    srcDir: string;
+    platformVersion: string;
+    [key: string]: unknown;
+}
 export interface TranslationContext {
     projectSourceDir: string;
     platformVersion: string;
@@ -60,11 +88,16 @@ export interface TranslationOptions {
     profile?: string;
 }
 export interface TranslationOptionsLocalDev extends TranslationOptions {
-    configFilesUpdatedSinceLastUpload?: Set<string>;
+    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>;