@hubspot/cli 8.0.10-experimental.6 → 8.0.10-experimental.7

package/lib/projects/projectProfiles.js

@@ -0,0 +1,140 @@
+import path from 'path';
+import { loadHsProfileFile, getHsProfileFilename, getAllHsProfiles, validateProfileVariables, } from '@hubspot/project-parsing-lib/profiles';
+import { commands, lib } from '../../lang/en.js';
+import { indent, uiBetaTag, uiLine } from '../ui/index.js';
+import { uiLogger } from '../ui/logger.js';
+import { getConfigAccountById } from '@hubspot/local-dev-lib/config';
+import SpinniesManager from '../ui/SpinniesManager.js';
+import { handleTranslate } from './upload.js';
+import { getErrorMessage } from '../errorHandlers/index.js';
+export function logProfileHeader(profileName) {
+    uiLine();
+    uiBetaTag(lib.projectProfiles.logs.usingProfile(getHsProfileFilename(profileName)));
+    uiLogger.log('');
+}
+export function logProfileFooter(profile, includeVariables = false) {
+    uiLogger.log(lib.projectProfiles.logs.profileTargetAccount(profile.accountId));
+    if (includeVariables) {
+        uiLogger.log('');
+        uiLogger.log(lib.projectProfiles.logs.profileVariables);
+        Object.entries(profile.variables ?? {}).forEach(([key, value]) => {
+            uiLogger.log(`  ${key}: ${value}`);
+        });
+    }
+    uiLine();
+    uiLogger.log('');
+}
+export function loadProfile(projectConfig, projectDir, profileName) {
+    if (!projectConfig || !projectDir) {
+        throw new Error(lib.projectProfiles.loadProfile.errors.noProjectConfig);
+    }
+    const projectSourceDir = path.join(projectDir, projectConfig.srcDir);
+    const profileFilename = getHsProfileFilename(profileName);
+    let profile;
+    try {
+        profile = loadHsProfileFile(projectSourceDir, profileName);
+    }
+    catch (e) {
+        throw new Error(lib.projectProfiles.loadProfile.errors.failedToLoadProfile(profileFilename));
+    }
+    if (!profile) {
+        throw new Error(lib.projectProfiles.loadProfile.errors.profileNotFound(profileFilename));
+    }
+    if (!profile.accountId) {
+        throw new Error(lib.projectProfiles.loadProfile.errors.missingAccountId(profileFilename));
+    }
+    try {
+        getConfigAccountById(profile.accountId);
+    }
+    catch (error) {
+        throw new Error(lib.projectProfiles.loadProfile.errors.listedAccountNotFound(profile.accountId, profileFilename));
+    }
+    return profile;
+}
+export async function enforceProfileUsage(projectConfig, projectDir) {
+    if (projectConfig && projectDir) {
+        const existingProfiles = await getAllHsProfiles(path.join(projectDir, projectConfig.srcDir));
+        if (existingProfiles.length > 0) {
+            throw new Error(lib.projectProfiles.exitIfUsingProfiles.errors.noProfileSpecified);
+        }
+    }
+}
+export async function loadAndValidateProfile(projectConfig, projectDir, profileName, silent = false) {
+    if (!profileName) {
+        await enforceProfileUsage(projectConfig, projectDir);
+        return;
+    }
+    if (!silent) {
+        logProfileHeader(profileName);
+    }
+    const profile = loadProfile(projectConfig, projectDir, profileName);
+    if (!silent) {
+        logProfileFooter(profile, true);
+    }
+    if (profile.variables) {
+        const validationResult = validateProfileVariables(profile.variables, profileName);
+        if (!validationResult.success) {
+            throw new Error(lib.projectProfiles.loadProfile.errors.profileNotValid(profileName, validationResult.errors));
+        }
+    }
+    return profile.accountId;
+}
+function formatProfileValidationError(error, leadingIndentationLevel = 0) {
+    // Trim leading whitespace and replace tabs with spaces to reducing indentations
+    const errorMessage = getErrorMessage(error)
+        .trimStart()
+        .replaceAll('\t', indent(2));
+    return `${indent(leadingIndentationLevel)}${errorMessage}\n`;
+}
+export async function validateProjectForProfile({ projectConfig, projectDir, profileName, derivedAccountId, indentSpinners = false, silent = false, }) {
+    let targetAccountId = derivedAccountId;
+    const spinnerName = `validatingProfile-${profileName}`;
+    const profileFilename = getHsProfileFilename(profileName);
+    if (!silent) {
+        SpinniesManager.add(spinnerName, {
+            text: commands.project.validate.spinners.validatingProfile(profileFilename),
+            indent: indentSpinners ? indent(1).length : 0,
+        });
+    }
+    try {
+        const accountId = await loadAndValidateProfile(projectConfig, projectDir, profileName, true);
+        targetAccountId = accountId || derivedAccountId;
+    }
+    catch (error) {
+        SpinniesManager.fail(spinnerName, {
+            text: commands.project.validate.spinners.profileValidationFailed(profileName),
+            failColor: 'white',
+        });
+        return [formatProfileValidationError(error)];
+    }
+    try {
+        await handleTranslate({
+            projectDir: projectDir,
+            projectConfig,
+            accountId: targetAccountId,
+            skipValidation: false,
+            profile: profileName,
+            includeTranslationErrorMessage: false,
+        });
+    }
+    catch (error) {
+        if (!silent) {
+            SpinniesManager.fail(spinnerName, {
+                text: commands.project.validate.spinners.invalidWithProfile(profileName),
+                failColor: 'white',
+            });
+        }
+        const errors = [
+            commands.project.validate.failureWithProfile(profileName),
+        ];
+        errors.push(formatProfileValidationError(error, 1));
+        return errors;
+    }
+    if (!silent) {
+        SpinniesManager.succeed(spinnerName, {
+            text: commands.project.validate.spinners.profileValidationSucceeded(profileFilename),
+            succeedColor: 'white',
+        });
+    }
+    return [];
+}

package/lib/projects/structure.d.ts

@@ -0,0 +1,18 @@
+import { ComponentTypes, Component, GenericComponentConfig, PublicAppComponentConfig, PrivateAppComponentConfig, AppCardComponentConfig } from '../../types/Projects.js';
+import type { IntermediateRepresentationNodeLocalDev } from '@hubspot/project-parsing-lib/translate';
+import { AppIRNode } from '../../types/ProjectComponents.js';
+export declare const CONFIG_FILES: {
+    [k in ComponentTypes]: string;
+};
+export declare function getComponentTypeFromConfigFile(configFile: string): ComponentTypes | null;
+export declare function loadConfigFile(configPath: string): GenericComponentConfig | null;
+export declare function getAppCardConfigs(appConfig: PublicAppComponentConfig | PrivateAppComponentConfig, appPath: string): Array<AppCardComponentConfig>;
+export declare function getIsLegacyApp(appConfig: GenericComponentConfig, appPath: string): boolean;
+export declare function findProjectComponents(projectSourceDir: string): Promise<Array<Component>>;
+export declare function getProjectComponentTypes(components: Array<Component>): {
+    [key in ComponentTypes]?: boolean;
+};
+export declare function getComponentUid(component?: Component | null): string | null;
+export declare function componentIsApp(component?: Component | null): component is Component<PublicAppComponentConfig | PrivateAppComponentConfig>;
+export declare function componentIsPublicApp(component?: Component | null): component is Component<PublicAppComponentConfig>;
+export declare function isAppIRNode(component: IntermediateRepresentationNodeLocalDev): component is AppIRNode;

package/lib/projects/structure.js

@@ -0,0 +1,130 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import { walk } from '@hubspot/local-dev-lib/fs';
+import { uiLogger } from '../ui/logger.js';
+import { logError } from '../errorHandlers/index.js';
+import { ComponentTypes, } from '../../types/Projects.js';
+import { IR_COMPONENT_TYPES, LEGACY_PRIVATE_APP_FILE, LEGACY_PUBLIC_APP_FILE, THEME_FILE, } from '../constants.js';
+export const CONFIG_FILES = {
+    [ComponentTypes.PrivateApp]: LEGACY_PRIVATE_APP_FILE,
+    [ComponentTypes.PublicApp]: LEGACY_PUBLIC_APP_FILE,
+    [ComponentTypes.HublTheme]: THEME_FILE,
+};
+export function getComponentTypeFromConfigFile(configFile) {
+    let key;
+    for (key in CONFIG_FILES) {
+        if (CONFIG_FILES[key] === configFile) {
+            return key;
+        }
+    }
+    return null;
+}
+export function loadConfigFile(configPath) {
+    if (configPath) {
+        try {
+            const source = fs.readFileSync(configPath);
+            const parsedConfig = JSON.parse(source.toString());
+            return parsedConfig;
+        }
+        catch (e) {
+            uiLogger.debug(e);
+        }
+    }
+    return null;
+}
+export function getAppCardConfigs(appConfig, appPath) {
+    const cardConfigs = [];
+    let cards;
+    if (appConfig && appConfig.extensions && appConfig.extensions.crm) {
+        cards = appConfig.extensions.crm.cards;
+    }
+    if (cards) {
+        cards.forEach(({ file }) => {
+            if (typeof file === 'string') {
+                const cardConfigPath = path.join(appPath, file);
+                const cardConfig = loadConfigFile(cardConfigPath);
+                if (cardConfig && 'type' in cardConfig) {
+                    cardConfigs.push(cardConfig);
+                }
+            }
+        });
+    }
+    return cardConfigs;
+}
+export function getIsLegacyApp(appConfig, appPath) {
+    let hasAnyReactExtensions = false;
+    if (appConfig && 'extensions' in appConfig) {
+        const cardConfigs = getAppCardConfigs(appConfig, appPath);
+        if (!cardConfigs.length) {
+            // Assume any app that does not have any cards is not legacy
+            return false;
+        }
+        cardConfigs.forEach(cardConfig => {
+            if (!hasAnyReactExtensions) {
+                const isReactExtension = cardConfig &&
+                    !!cardConfig.data &&
+                    !!cardConfig.data.module &&
+                    !!cardConfig.data.module.file;
+                hasAnyReactExtensions = isReactExtension;
+            }
+        });
+    }
+    return !hasAnyReactExtensions;
+}
+export async function findProjectComponents(projectSourceDir) {
+    const components = [];
+    let projectFiles = [];
+    try {
+        projectFiles = await walk(projectSourceDir);
+    }
+    catch (e) {
+        logError(e);
+    }
+    projectFiles.forEach(projectFile => {
+        // Find app components
+        const { base, dir } = path.parse(projectFile);
+        if (Object.values(CONFIG_FILES).includes(base)) {
+            const parsedConfig = loadConfigFile(projectFile);
+            if (parsedConfig) {
+                const isLegacy = getIsLegacyApp(parsedConfig, dir);
+                const isHublTheme = base === CONFIG_FILES[ComponentTypes.HublTheme];
+                const componentType = getComponentTypeFromConfigFile(base);
+                if (componentType) {
+                    components.push({
+                        type: componentType,
+                        config: parsedConfig,
+                        runnable: !isLegacy && !isHublTheme,
+                        path: dir,
+                    });
+                }
+            }
+        }
+    });
+    return components;
+}
+export function getProjectComponentTypes(components) {
+    const projectContents = {};
+    components.forEach(({ type }) => (projectContents[type] = true));
+    return projectContents;
+}
+export function getComponentUid(component) {
+    if (!component) {
+        return null;
+    }
+    else if ('uid' in component.config) {
+        return component.config.uid;
+    }
+    else {
+        return component.config.data.uid;
+    }
+}
+export function componentIsApp(component) {
+    return (component?.type === ComponentTypes.PublicApp ||
+        component?.type === ComponentTypes.PrivateApp);
+}
+export function componentIsPublicApp(component) {
+    return component?.type === ComponentTypes.PublicApp;
+}
+export function isAppIRNode(component) {
+    return component.componentType === IR_COMPONENT_TYPES.APPLICATION;
+}

package/lib/projects/ui.d.ts

@@ -0,0 +1 @@
+export declare function logFeedbackMessage(buildId: number): void;

package/lib/projects/ui.js

@@ -0,0 +1,12 @@
+import { uiLogger } from '../ui/logger.js';
+import { FEEDBACK_INTERVAL } from '../constants.js';
+import { uiLine } from '../ui/index.js';
+import { lib } from '../../lang/en.js';
+export function logFeedbackMessage(buildId) {
+    if (buildId > 0 && buildId % FEEDBACK_INTERVAL === 0) {
+        uiLine();
+        uiLogger.log(lib.projects.logFeedbackMessage.feedbackHeader);
+        uiLine();
+        uiLogger.log(lib.projects.logFeedbackMessage.feedbackMessage);
+    }
+}

package/lib/projects/uieLinting.d.ts

@@ -0,0 +1,33 @@
+export declare const REQUIRED_PACKAGES_AND_MIN_VERSIONS: {
+    readonly eslint: "9.0.0";
+    readonly '@typescript-eslint/eslint-plugin': "8.46.4";
+    readonly '@typescript-eslint/parser': "8.46.4";
+    readonly 'typescript-eslint': "8.46.4";
+    readonly jiti: "2.6.1";
+};
+export declare function isEslintInstalled(directory: string): boolean;
+export declare function areAllLintPackagesInstalled(directory: string): boolean;
+export declare function getMissingLintPackages(directory: string): {
+    missingPackages: string[];
+};
+export declare function hasEslintConfig(directory: string): boolean;
+export declare function hasDeprecatedEslintConfig(directory: string): boolean;
+export declare function getDeprecatedEslintConfigFiles(directory: string): string[];
+export declare function createEslintConfig(directory: string): string;
+export declare function lintPackagesInDirectory(directory: string, projectDir?: string): Promise<{
+    success: boolean;
+    output: string;
+}>;
+export declare function lintPackages(lintLocations?: string[], projectDir?: string): Promise<{
+    success: boolean;
+    results: Array<{
+        location: string;
+        success: boolean;
+        output: string;
+    }>;
+}>;
+export declare function displayLintResults(results: Array<{
+    location: string;
+    success: boolean;
+    output: string;
+}>): void;

package/lib/projects/uieLinting.js

@@ -0,0 +1,220 @@
+import fs from 'fs';
+import path from 'path';
+import util from 'util';
+import semver from 'semver';
+import { exec as execAsync } from 'node:child_process';
+import { getProjectPackageJsonLocations, isPackageInstalled, } from '../dependencyManagement.js';
+import { commands } from '../../lang/en.js';
+import { uiLogger } from '../ui/logger.js';
+import { safeGetPackageJsonCached } from '../npm/packageJson.js';
+export const REQUIRED_PACKAGES_AND_MIN_VERSIONS = {
+    eslint: '9.0.0',
+    '@typescript-eslint/eslint-plugin': '8.46.4',
+    '@typescript-eslint/parser': '8.46.4',
+    'typescript-eslint': '8.46.4',
+    jiti: '2.6.1',
+};
+const ESLINT_CONFIG_FILES = [
+    'eslint.config.mts',
+    'eslint.config.ts',
+    'eslint.config.cts',
+    'eslint.config.js',
+    'eslint.config.mjs',
+    'eslint.config.cjs',
+];
+const DEPRECATED_ESLINT_CONFIG_FILES = [
+    '.eslintrc.js',
+    '.eslintrc.cjs',
+    '.eslintrc.yaml',
+    '.eslintrc.yml',
+    '.eslintrc.json',
+    '.eslintrc',
+];
+const ESLINT_CONFIG_TEMPLATE = `import { defineConfig } from "eslint/config";
+import tsParser from "@typescript-eslint/parser";
+
+export default defineConfig([
+  {
+    files: ["**/*.{js,mjs,cjs,ts,mts,cts,jsx,tsx}"],
+    languageOptions: {
+      parser: tsParser,
+      parserOptions: {
+        ecmaVersion: "latest",
+        sourceType: "module",
+        ecmaFeatures: {
+          jsx: true
+        }
+      }
+    },
+    rules: {
+      "no-console": ["warn", { allow: ["warn", "error"] }]
+    }
+  },
+]);
+`;
+function getPackageVersionFromPackageJson(directory, packageName) {
+    const packageJsonPath = path.join(directory, 'package.json');
+    const packageJson = safeGetPackageJsonCached(packageJsonPath);
+    if (!packageJson) {
+        return null;
+    }
+    const version = packageJson.dependencies?.[packageName] ||
+        packageJson.devDependencies?.[packageName];
+    return version || null;
+}
+function isPackageVersionValid(directory, packageName) {
+    const versionRange = getPackageVersionFromPackageJson(directory, packageName);
+    if (!versionRange) {
+        return false;
+    }
+    const minimumVersion = REQUIRED_PACKAGES_AND_MIN_VERSIONS[packageName];
+    if (!minimumVersion) {
+        // If no minimum version specified, any version is valid
+        return true;
+    }
+    try {
+        // Check if the version range satisfies the minimum version
+        // For ranges like ^9.0.0, ~8.5.0, >=9.0.0, etc.
+        const minVersionSatisfied = semver.satisfies(minimumVersion, versionRange, {
+            includePrerelease: true,
+        });
+        const coercedVersion = semver.minVersion(versionRange);
+        if (coercedVersion) {
+            return semver.gte(coercedVersion, minimumVersion);
+        }
+        return minVersionSatisfied;
+    }
+    catch (error) {
+        return false;
+    }
+}
+export function isEslintInstalled(directory) {
+    return isPackageInstalled(directory, 'eslint');
+}
+export function areAllLintPackagesInstalled(directory) {
+    return Object.keys(REQUIRED_PACKAGES_AND_MIN_VERSIONS).every(pkg => {
+        const installed = isPackageInstalled(directory, pkg);
+        const validVersion = isPackageVersionValid(directory, pkg);
+        return installed && validVersion;
+    });
+}
+export function getMissingLintPackages(directory) {
+    const missingPackages = [];
+    for (const packageName of Object.keys(REQUIRED_PACKAGES_AND_MIN_VERSIONS)) {
+        const isInstalled = isPackageInstalled(directory, packageName);
+        const isValidVersion = isPackageVersionValid(directory, packageName);
+        if (!isInstalled || !isValidVersion) {
+            missingPackages.push(packageName);
+        }
+    }
+    return { missingPackages };
+}
+export function hasEslintConfig(directory) {
+    return ESLINT_CONFIG_FILES.some(configFile => {
+        const configPath = path.join(directory, configFile);
+        return fs.existsSync(configPath);
+    });
+}
+export function hasDeprecatedEslintConfig(directory) {
+    return DEPRECATED_ESLINT_CONFIG_FILES.some(configFile => {
+        const configPath = path.join(directory, configFile);
+        return fs.existsSync(configPath);
+    });
+}
+export function getDeprecatedEslintConfigFiles(directory) {
+    return DEPRECATED_ESLINT_CONFIG_FILES.filter(configFile => {
+        const configPath = path.join(directory, configFile);
+        return fs.existsSync(configPath);
+    });
+}
+export function createEslintConfig(directory) {
+    const configPath = path.join(directory, 'eslint.config.mts');
+    try {
+        fs.writeFileSync(configPath, ESLINT_CONFIG_TEMPLATE, 'utf-8');
+        return path.relative(process.cwd(), configPath);
+    }
+    catch (error) {
+        uiLogger.error(commands.project.lint.failedToCreateEslintConfig(configPath));
+        throw error;
+    }
+}
+export async function lintPackagesInDirectory(directory, projectDir) {
+    const displayPath = projectDir
+        ? path.relative(projectDir, directory)
+        : directory;
+    const exec = util.promisify(execAsync);
+    const lintCommand = 'npx eslint . --color';
+    try {
+        const { stdout, stderr } = await exec(lintCommand, {
+            cwd: directory,
+            maxBuffer: 10 * 1024 * 1024, // 10MB buffer for large outputs
+        });
+        let output = `\n${displayPath}:\n`;
+        if (stdout && stdout.trim()) {
+            output += stdout;
+        }
+        else {
+            output += '  No linting issues found.\n';
+        }
+        if (stderr && stderr.trim()) {
+            output += stderr;
+        }
+        return { success: true, output };
+    }
+    catch (error) {
+        // ESLint returns exit code 1 when there are linting errors
+        // but still provides useful output in stdout/stderr
+        let output = `\n${displayPath}:\n`;
+        if (error && typeof error === 'object' && 'stdout' in error) {
+            const execError = error;
+            if (execError.stdout) {
+                output += execError.stdout;
+            }
+            if (execError.stderr) {
+                output += execError.stderr;
+            }
+        }
+        return { success: false, output };
+    }
+}
+export async function lintPackages(lintLocations, projectDir) {
+    const locations = lintLocations || (await getProjectPackageJsonLocations());
+    const results = [];
+    for (const location of locations) {
+        const result = await lintPackagesInDirectory(location, projectDir);
+        const displayPath = projectDir
+            ? path.relative(projectDir, location)
+            : location;
+        results.push({ location: displayPath, ...result });
+    }
+    const failedLocations = results.filter(r => !r.success);
+    return {
+        success: failedLocations.length === 0,
+        results,
+    };
+}
+export function displayLintResults(results) {
+    // Display all output
+    results.forEach(r => {
+        uiLogger.log(r.output);
+    });
+    // Summary
+    const failedLocations = results.filter(r => !r.success);
+    const passedLocations = results.filter(r => r.success);
+    uiLogger.log('\n' + '='.repeat(50));
+    if (passedLocations.length > 0) {
+        uiLogger.success(`Linting passed in ${passedLocations.length} ${passedLocations.length === 1 ? 'directory' : 'directories'}:`);
+        passedLocations.forEach(r => {
+            uiLogger.log(`  ✓ ${r.location}`);
+        });
+    }
+    if (failedLocations.length > 0) {
+        if (passedLocations.length > 0) {
+            uiLogger.log('');
+        }
+        uiLogger.error(`Linting failed in ${failedLocations.length} ${failedLocations.length === 1 ? 'directory' : 'directories'}:`);
+        failedLocations.forEach(r => {
+            uiLogger.log(`  ✗ ${r.location}`);
+        });
+    }
+}

package/lib/projects/upload.d.ts

@@ -0,0 +1,33 @@
+import { FileResult } from 'tmp';
+import { ProjectConfig } from '../../types/Projects.js';
+type ProjectUploadCallbackFunction<T> = (accountId: number, projectConfig: ProjectConfig, tempFile: FileResult, buildId: number) => Promise<T>;
+type ProjectUploadResult<T> = {
+    result?: T;
+    uploadError?: unknown;
+    projectNotFound?: boolean;
+};
+type HandleProjectUploadArg<T> = {
+    accountId: number;
+    projectConfig: ProjectConfig;
+    projectDir: string;
+    callbackFunc: ProjectUploadCallbackFunction<T>;
+    uploadMessage?: string;
+    forceCreate?: boolean;
+    isUploadCommand?: boolean;
+    sendIR?: boolean;
+    skipValidation?: boolean;
+    profile?: string;
+};
+export declare function handleProjectUpload<T>({ accountId, projectConfig, projectDir, callbackFunc, profile, uploadMessage, forceCreate, isUploadCommand, sendIR, skipValidation, }: HandleProjectUploadArg<T>): Promise<ProjectUploadResult<T>>;
+export declare function validateSourceDirectory(srcDir: string, projectConfig: ProjectConfig, projectDir: string): Promise<void>;
+export declare function validateNoHSMetaMismatch(srcDir: string, projectConfig: ProjectConfig): Promise<void>;
+type HandleTranslateArg = {
+    projectDir: string;
+    projectConfig: ProjectConfig;
+    accountId: number;
+    skipValidation: boolean;
+    profile?: string;
+    includeTranslationErrorMessage?: boolean;
+};
+export declare function handleTranslate({ projectDir, projectConfig, accountId, skipValidation, profile, includeTranslationErrorMessage, }: HandleTranslateArg): Promise<unknown>;
+export {};