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

package/lib/projects/projectProfiles.js

@@ -1,140 +0,0 @@
-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

@@ -1,18 +0,0 @@
-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

@@ -1,130 +0,0 @@
-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

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

package/lib/projects/ui.js

@@ -1,12 +0,0 @@
-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

@@ -1,33 +0,0 @@
-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

@@ -1,220 +0,0 @@
-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

@@ -1,33 +0,0 @@
-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 {};