@hubspot/cli 8.14.0 → 8.15.0-beta.0

package/lib/jsonOutput/info.js

@@ -0,0 +1,19 @@
+import { z } from 'zod';
+export const ProjectInfoSchema = z.object({
+    projectName: z.string(),
+    platformVersion: z.string(),
+    projectId: z.number(),
+    deployedBuildId: z.number(),
+    autoDeployEnabled: z.boolean(),
+    projectUrl: z.string().optional(),
+    app: z
+        .object({
+        name: z.string(),
+        id: z.number(),
+        uid: z.string(),
+        authType: z.string().optional(),
+        distributionType: z.string().optional(),
+    })
+        .optional(),
+    components: z.array(z.object({ uid: z.string(), type: z.string() })),
+});

package/lib/jsonOutput/installApp.d.ts

@@ -0,0 +1,11 @@
+import { z } from 'zod';
+export declare const InstallAppSchema: z.ZodObject<{
+    appId: z.ZodNumber;
+    appUid: z.ZodString;
+    accountId: z.ZodNumber;
+    projectId: z.ZodNumber;
+    installationState: z.ZodString;
+    installed: z.ZodBoolean;
+    reinstalled: z.ZodBoolean;
+}, z.core.$strip>;
+export type InstallAppJsonOutput = z.infer<typeof InstallAppSchema>;

package/lib/jsonOutput/installApp.js

@@ -0,0 +1,10 @@
+import { z } from 'zod';
+export const InstallAppSchema = z.object({
+    appId: z.number(),
+    appUid: z.string(),
+    accountId: z.number(),
+    projectId: z.number(),
+    installationState: z.string(),
+    installed: z.boolean(),
+    reinstalled: z.boolean(),
+});

package/lib/jsonOutput/listBuilds.d.ts

@@ -0,0 +1,75 @@
+import { z } from 'zod';
+import { Build } from '@hubspot/local-dev-lib/types/Build';
+declare const BuildSubbuildStatusSchema: z.ZodObject<{
+    buildName: z.ZodString;
+    buildType: z.ZodString;
+    status: z.ZodString;
+    errorMessage: z.ZodOptional<z.ZodString>;
+    startedAt: z.ZodOptional<z.ZodString>;
+    finishedAt: z.ZodOptional<z.ZodString>;
+    rootPath: z.ZodOptional<z.ZodString>;
+    id: z.ZodOptional<z.ZodString>;
+    visible: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+export declare const BuildSchema: z.ZodObject<{
+    buildId: z.ZodNumber;
+    status: z.ZodString;
+    isDeployed: z.ZodBoolean;
+    isAutoDeployEnabled: z.ZodOptional<z.ZodBoolean>;
+    deployableState: z.ZodOptional<z.ZodString>;
+    platformVersion: z.ZodOptional<z.ZodString>;
+    uploadMessage: z.ZodOptional<z.ZodString>;
+    enqueuedAt: z.ZodOptional<z.ZodString>;
+    startedAt: z.ZodOptional<z.ZodString>;
+    finishedAt: z.ZodOptional<z.ZodString>;
+    createdAt: z.ZodOptional<z.ZodString>;
+    subbuildStatuses: z.ZodArray<z.ZodObject<{
+        buildName: z.ZodString;
+        buildType: z.ZodString;
+        status: z.ZodString;
+        errorMessage: z.ZodOptional<z.ZodString>;
+        startedAt: z.ZodOptional<z.ZodString>;
+        finishedAt: z.ZodOptional<z.ZodString>;
+        rootPath: z.ZodOptional<z.ZodString>;
+        id: z.ZodOptional<z.ZodString>;
+        visible: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export declare const ProjectBuildsListSchema: z.ZodObject<{
+    projectName: z.ZodString;
+    deployedBuildId: z.ZodOptional<z.ZodNumber>;
+    results: z.ZodArray<z.ZodObject<{
+        buildId: z.ZodNumber;
+        status: z.ZodString;
+        isDeployed: z.ZodBoolean;
+        isAutoDeployEnabled: z.ZodOptional<z.ZodBoolean>;
+        deployableState: z.ZodOptional<z.ZodString>;
+        platformVersion: z.ZodOptional<z.ZodString>;
+        uploadMessage: z.ZodOptional<z.ZodString>;
+        enqueuedAt: z.ZodOptional<z.ZodString>;
+        startedAt: z.ZodOptional<z.ZodString>;
+        finishedAt: z.ZodOptional<z.ZodString>;
+        createdAt: z.ZodOptional<z.ZodString>;
+        subbuildStatuses: z.ZodArray<z.ZodObject<{
+            buildName: z.ZodString;
+            buildType: z.ZodString;
+            status: z.ZodString;
+            errorMessage: z.ZodOptional<z.ZodString>;
+            startedAt: z.ZodOptional<z.ZodString>;
+            finishedAt: z.ZodOptional<z.ZodString>;
+            rootPath: z.ZodOptional<z.ZodString>;
+            id: z.ZodOptional<z.ZodString>;
+            visible: z.ZodOptional<z.ZodBoolean>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+    paging: z.ZodOptional<z.ZodObject<{
+        next: z.ZodObject<{
+            after: z.ZodString;
+        }, z.core.$strip>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type BuildSubbuildStatusJsonOutput = z.infer<typeof BuildSubbuildStatusSchema>;
+export type BuildJsonOutput = z.infer<typeof BuildSchema>;
+export type ProjectBuildsListJsonOutput = z.infer<typeof ProjectBuildsListSchema>;
+export declare function mapBuildToJsonOutput(build: Build, deployedBuildId?: number): BuildJsonOutput;
+export {};

package/lib/jsonOutput/listBuilds.js

@@ -0,0 +1,65 @@
+import { z } from 'zod';
+const BuildSubbuildStatusSchema = z.object({
+    buildName: z.string(),
+    buildType: z.string(),
+    status: z.string(),
+    errorMessage: z.string().optional(),
+    startedAt: z.string().optional(),
+    finishedAt: z.string().optional(),
+    rootPath: z.string().optional(),
+    id: z.string().optional(),
+    visible: z.boolean().optional(),
+});
+export const BuildSchema = z.object({
+    buildId: z.number(),
+    status: z.string(),
+    isDeployed: z.boolean(),
+    isAutoDeployEnabled: z.boolean().optional(),
+    deployableState: z.string().optional(),
+    platformVersion: z.string().optional(),
+    uploadMessage: z.string().optional(),
+    enqueuedAt: z.string().optional(),
+    startedAt: z.string().optional(),
+    finishedAt: z.string().optional(),
+    createdAt: z.string().optional(),
+    subbuildStatuses: z.array(BuildSubbuildStatusSchema),
+});
+export const ProjectBuildsListSchema = z.object({
+    projectName: z.string(),
+    deployedBuildId: z.number().optional(),
+    results: z.array(BuildSchema),
+    paging: z
+        .object({
+        next: z.object({
+            after: z.string(),
+        }),
+    })
+        .optional(),
+});
+export function mapBuildToJsonOutput(build, deployedBuildId) {
+    const { buildId, status, isAutoDeployEnabled, deployableState, platformVersion, uploadMessage, enqueuedAt, startedAt, finishedAt, createdAt, subbuildStatuses, } = build;
+    return {
+        buildId,
+        status,
+        isDeployed: buildId === deployedBuildId,
+        isAutoDeployEnabled,
+        deployableState,
+        platformVersion,
+        uploadMessage,
+        enqueuedAt,
+        startedAt,
+        finishedAt,
+        createdAt,
+        subbuildStatuses: subbuildStatuses.map(subbuild => ({
+            buildName: subbuild.buildName,
+            buildType: subbuild.buildType,
+            status: subbuild.status,
+            errorMessage: subbuild.errorMessage,
+            startedAt: subbuild.startedAt,
+            finishedAt: subbuild.finishedAt,
+            rootPath: subbuild.rootPath,
+            id: subbuild.id,
+            visible: subbuild.visible,
+        })),
+    };
+}

package/lib/jsonOutput/projectList.d.ts

@@ -0,0 +1,29 @@
+import { z } from 'zod';
+import { Project } from '@hubspot/local-dev-lib/types/Project';
+declare const ProjectListItemSchema: z.ZodObject<{
+    name: z.ZodString;
+    id: z.ZodNumber;
+    createdAt: z.ZodNumber;
+    updatedAt: z.ZodNumber;
+    platformVersion: z.ZodOptional<z.ZodString>;
+    latestBuildId: z.ZodOptional<z.ZodNumber>;
+    deployedBuildId: z.ZodOptional<z.ZodNumber>;
+    isLocked: z.ZodBoolean;
+}, z.core.$strip>;
+export declare const ProjectListSchema: z.ZodObject<{
+    accountId: z.ZodNumber;
+    results: z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        id: z.ZodNumber;
+        createdAt: z.ZodNumber;
+        updatedAt: z.ZodNumber;
+        platformVersion: z.ZodOptional<z.ZodString>;
+        latestBuildId: z.ZodOptional<z.ZodNumber>;
+        deployedBuildId: z.ZodOptional<z.ZodNumber>;
+        isLocked: z.ZodBoolean;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type ProjectListItemJsonOutput = z.infer<typeof ProjectListItemSchema>;
+export type ProjectListJsonOutput = z.infer<typeof ProjectListSchema>;
+export declare function mapProjectToListItem(project: Project): ProjectListItemJsonOutput;
+export {};

package/lib/jsonOutput/projectList.js

@@ -0,0 +1,28 @@
+import { z } from 'zod';
+const ProjectListItemSchema = z.object({
+    name: z.string(),
+    id: z.number(),
+    createdAt: z.number(),
+    updatedAt: z.number(),
+    platformVersion: z.string().optional(),
+    latestBuildId: z.number().optional(),
+    deployedBuildId: z.number().optional(),
+    isLocked: z.boolean(),
+});
+export const ProjectListSchema = z.object({
+    accountId: z.number(),
+    results: z.array(ProjectListItemSchema),
+});
+export function mapProjectToListItem(project) {
+    const { name, id, createdAt, updatedAt, isLocked, latestBuild, deployedBuildId, } = project;
+    return {
+        name,
+        id,
+        createdAt,
+        updatedAt,
+        platformVersion: latestBuild?.platformVersion,
+        latestBuildId: latestBuild?.buildId,
+        deployedBuildId,
+        isLocked,
+    };
+}

package/lib/jsonOutput/release.d.ts

@@ -0,0 +1,42 @@
+import { z } from 'zod';
+import { Release } from '../../api/releases.js';
+declare const ReleaseComponentSchema: z.ZodObject<{
+    buildType: z.ZodString;
+    buildName: z.ZodOptional<z.ZodString>;
+    rootPath: z.ZodOptional<z.ZodString>;
+    id: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare const ReleaseSchema: z.ZodObject<{
+    releaseTag: z.ZodString;
+    buildId: z.ZodNumber;
+    createdAt: z.ZodString;
+    components: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        buildType: z.ZodString;
+        buildName: z.ZodOptional<z.ZodString>;
+        rootPath: z.ZodOptional<z.ZodString>;
+        id: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;
+export declare const ReleaseListSchema: z.ZodObject<{
+    results: z.ZodArray<z.ZodObject<{
+        releaseTag: z.ZodString;
+        buildId: z.ZodNumber;
+        createdAt: z.ZodString;
+        components: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            buildType: z.ZodString;
+            buildName: z.ZodOptional<z.ZodString>;
+            rootPath: z.ZodOptional<z.ZodString>;
+            id: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>>;
+    }, z.core.$strip>>;
+    paging: z.ZodOptional<z.ZodObject<{
+        next: z.ZodObject<{
+            after: z.ZodString;
+        }, z.core.$strip>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type ReleaseComponentJsonOutput = z.infer<typeof ReleaseComponentSchema>;
+export type ReleaseJsonOutput = z.infer<typeof ReleaseSchema>;
+export type ReleaseListJsonOutput = z.infer<typeof ReleaseListSchema>;
+export declare function mapReleaseToJsonOutput(release: Release): ReleaseJsonOutput;
+export {};

package/lib/jsonOutput/release.js

@@ -0,0 +1,37 @@
+import { z } from 'zod';
+const ReleaseComponentSchema = z.object({
+    buildType: z.string(),
+    buildName: z.string().optional(),
+    rootPath: z.string().optional(),
+    id: z.string().optional(),
+});
+export const ReleaseSchema = z.object({
+    releaseTag: z.string(),
+    buildId: z.number(),
+    createdAt: z.string(),
+    components: z.array(ReleaseComponentSchema).optional(),
+});
+export const ReleaseListSchema = z.object({
+    results: z.array(ReleaseSchema),
+    paging: z
+        .object({
+        next: z.object({
+            after: z.string(),
+        }),
+    })
+        .optional(),
+});
+export function mapReleaseToJsonOutput(release) {
+    const { releaseTag, buildId, createdAt, components } = release;
+    return {
+        releaseTag,
+        buildId,
+        createdAt,
+        components: components?.map(({ buildType, buildName, rootPath, id }) => ({
+            buildType,
+            buildName,
+            rootPath,
+            id,
+        })),
+    };
+}

package/lib/jsonOutput/upload.d.ts

@@ -0,0 +1,29 @@
+import { z } from 'zod';
+import { HubSpotConfigAccount } from '@hubspot/local-dev-lib/types/Accounts';
+declare const PreviewSchema: z.ZodObject<{
+    releaseTag: z.ZodOptional<z.ZodString>;
+    succeeded: z.ZodBoolean;
+}, z.core.$strip>;
+declare const TargetAccountSchema: z.ZodObject<{
+    accountId: z.ZodNumber;
+    accountName: z.ZodOptional<z.ZodString>;
+    accountType: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare const UploadSchema: z.ZodObject<{
+    targetAccount: z.ZodOptional<z.ZodObject<{
+        accountId: z.ZodNumber;
+        accountName: z.ZodOptional<z.ZodString>;
+        accountType: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    buildId: z.ZodOptional<z.ZodNumber>;
+    deployId: z.ZodOptional<z.ZodNumber>;
+    preview: z.ZodOptional<z.ZodObject<{
+        releaseTag: z.ZodOptional<z.ZodString>;
+        succeeded: z.ZodBoolean;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type PreviewJsonOutput = z.infer<typeof PreviewSchema>;
+export type TargetAccountJsonOutput = z.infer<typeof TargetAccountSchema>;
+export type UploadJsonOutput = z.infer<typeof UploadSchema>;
+export declare function mapAccountToTargetAccount(accountId: number, account?: HubSpotConfigAccount | null): TargetAccountJsonOutput;
+export {};

package/lib/jsonOutput/upload.js

@@ -0,0 +1,23 @@
+import { z } from 'zod';
+const PreviewSchema = z.object({
+    releaseTag: z.string().optional(),
+    succeeded: z.boolean(),
+});
+const TargetAccountSchema = z.object({
+    accountId: z.number(),
+    accountName: z.string().optional(),
+    accountType: z.string().optional(),
+});
+export const UploadSchema = z.object({
+    targetAccount: TargetAccountSchema.optional(),
+    buildId: z.number().optional(),
+    deployId: z.number().optional(),
+    preview: PreviewSchema.optional(),
+});
+export function mapAccountToTargetAccount(accountId, account) {
+    return {
+        accountId,
+        accountName: account?.name,
+        accountType: account?.accountType,
+    };
+}

package/lib/npm/packageJson.js

@@ -92,7 +92,7 @@ const findAllPackageJsonFilesInDirectoryCached = async (directory) => {
  * @returns Array of absolute paths to package.json files in the project
  */
 export async function findAllPackageJsonFilesInProjectCached() {
-    const projectConfig = await getProjectConfig();
+    const projectConfig = getProjectConfig();
     const { projectDir } = projectConfig;
     if (!projectDir) {
         return [];

package/lib/projects/ProjectLogsManager.js

@@ -34,10 +34,7 @@ class _ProjectLogsManager {
         this.functions = [];
     }
     async init(accountId) {
-        const { projectConfig } = await getProjectConfig();
-        if (!projectConfig || !projectConfig.name) {
-            throw new Error(commands.project.logs.errors.noProjectConfig);
-        }
+        const { projectConfig } = getProjectConfig();
         this.projectConfig = projectConfig;
         this.projectName = projectConfig.name;
         this.accountId = accountId;

package/lib/projects/config.d.ts

@@ -1,9 +1,10 @@
-import { ProjectConfig } from '../../types/Projects.js';
+import type { ProjectConfig } from '@hubspot/project-parsing-lib/projects';
+export { ProjectConfigValidationError } from '@hubspot/project-parsing-lib/projects';
+export type { ProjectConfig } from '@hubspot/project-parsing-lib/projects';
 export declare function writeProjectConfig(configPath: string, config: ProjectConfig): boolean;
 export declare function getIsInProject(dir?: string): boolean;
 export interface LoadedProjectConfig {
-    projectDir: string | null;
-    projectConfig: ProjectConfig | null;
+    projectDir: string;
+    projectConfig: ProjectConfig;
 }
-export declare function getProjectConfig(dir?: string): Promise<LoadedProjectConfig>;
-export declare function validateProjectConfig(projectConfig: ProjectConfig | null, projectDir: string | null): asserts projectConfig is ProjectConfig;
+export declare function getProjectConfig(dir?: string): LoadedProjectConfig;

package/lib/projects/config.js

@@ -2,10 +2,11 @@ import fs from 'fs-extra';
 import path from 'path';
 import findup from 'findup-sync';
 import { getAbsoluteFilePath, getCwd } from '@hubspot/local-dev-lib/path';
+import { parseProjectConfig, ProjectConfigValidationError, } from '@hubspot/project-parsing-lib/projects';
 import { PROJECT_CONFIG_FILE } from '../constants.js';
 import { lib } from '../../lang/en.js';
 import { uiLogger } from '../ui/logger.js';
-import ProjectValidationError from '../errors/ProjectValidationError.js';
+export { ProjectConfigValidationError } from '@hubspot/project-parsing-lib/projects';
 export function writeProjectConfig(configPath, config) {
     try {
         fs.ensureFileSync(configPath);
@@ -30,44 +31,12 @@ function getProjectConfigPath(dir) {
     });
     return configPath;
 }
-export async function getProjectConfig(dir) {
+export function getProjectConfig(dir) {
     const configPath = getProjectConfigPath(dir);
     if (!configPath) {
-        return { projectConfig: null, projectDir: null };
-    }
-    try {
-        const config = fs.readFileSync(configPath);
-        const projectConfig = JSON.parse(config.toString());
-        return {
-            projectDir: path.dirname(configPath),
-            projectConfig,
-        };
-    }
-    catch (e) {
-        uiLogger.error(lib.projects.getProjectConfig.error);
-        return { projectConfig: null, projectDir: null };
-    }
-}
-export function validateProjectConfig(projectConfig, projectDir) {
-    if (!projectConfig || !projectDir) {
-        throw new ProjectValidationError(lib.projects.validateProjectConfig.configNotFound);
-    }
-    const missingFields = [];
-    if (!projectConfig.name) {
-        missingFields.push('name');
-    }
-    if (!projectConfig.srcDir) {
-        missingFields.push('srcDir');
-    }
-    if (missingFields.length > 0) {
-        throw new ProjectValidationError(lib.projects.validateProjectConfig.configMissingFields(missingFields));
-    }
-    const resolvedPath = path.resolve(projectDir, projectConfig.srcDir);
-    if (!resolvedPath.startsWith(projectDir)) {
-        const projectConfigFile = path.relative('.', path.join(projectDir, PROJECT_CONFIG_FILE));
-        throw new ProjectValidationError(lib.projects.validateProjectConfig.srcOutsideProjectDir(projectConfigFile, projectConfig.srcDir));
-    }
-    if (!fs.existsSync(resolvedPath)) {
-        throw new ProjectValidationError(lib.projects.validateProjectConfig.srcDirNotFound(projectConfig.srcDir, projectDir));
+        throw new ProjectConfigValidationError(lib.projects.validateProjectConfig.configNotFound);
     }
+    const projectDir = path.dirname(configPath);
+    const projectConfig = parseProjectConfig(projectDir);
+    return { projectDir, projectConfig };
 }

package/lib/projects/create/tracking.d.ts

@@ -0,0 +1 @@
+export declare function getProjectCreateFailureReason(error: unknown): string;

package/lib/projects/create/tracking.js

@@ -0,0 +1,27 @@
+import { isFileSystemError, isGithubRateLimitError, isGithubError, getHttpStatusFromError, } from '@hubspot/local-dev-lib/errors/index';
+const FAILURE_REASON = {
+    GITHUB_RATE_LIMIT: 'github-rate-limit',
+    GITHUB_NOT_FOUND: 'github-not-found',
+    GITHUB_ERROR: 'github-error',
+    HTTP_ERROR: 'http-error',
+    FILESYSTEM: 'filesystem',
+    UNKNOWN: 'unknown',
+};
+export function getProjectCreateFailureReason(error) {
+    if (isGithubRateLimitError(error)) {
+        return FAILURE_REASON.GITHUB_RATE_LIMIT;
+    }
+    const httpStatus = getHttpStatusFromError(error);
+    if (httpStatus !== undefined) {
+        if (isGithubError(error)) {
+            return httpStatus === 404
+                ? FAILURE_REASON.GITHUB_NOT_FOUND
+                : FAILURE_REASON.GITHUB_ERROR;
+        }
+        return FAILURE_REASON.HTTP_ERROR;
+    }
+    if (isFileSystemError(error)) {
+        return FAILURE_REASON.FILESYSTEM;
+    }
+    return FAILURE_REASON.UNKNOWN;
+}

package/lib/projects/delete.js

@@ -79,7 +79,20 @@ export async function checkDeployedComponents(accountId, projectName) {
     const platformVersion = projectData.deployedBuild?.platformVersion ||
         projectData.latestBuild?.platformVersion;
     if (!platformVersion) {
-        throw new Error(commands.project.delete.errors.noPlatformVersion);
+        // A build exists but carries no platform version. That is inconsistent data rather than an
+        // empty project, and the build may have deployed components, so keep failing loudly instead of
+        // silently skipping cleanup.
+        if (projectData.deployedBuild || projectData.latestBuild) {
+            throw new Error(commands.project.delete.errors.noPlatformVersion);
+        }
+        // No builds at all, so nothing is deployed and there is no platform version to branch on. This
+        // happens whenever a project's very first upload fails, for example on a platform version that
+        // is not active, and previously left the project impossible to delete.
+        return {
+            platformVersion: '',
+            hasUnifiedComponents: false,
+            projectId: projectData.id,
+        };
     }
     if (isLegacyProject(platformVersion)) {
         const userVisibleComponents = [];

package/lib/projects/localDev/LocalDevProcess.js

@@ -108,17 +108,17 @@ class LocalDevProcess {
         }
     }
     async projectConfigValidForUpload() {
-        const { projectConfig } = await getProjectConfig();
-        if (!projectConfig) {
+        let projectConfig;
+        try {
+            ({ projectConfig } = getProjectConfig());
+        }
+        catch {
             return false;
         }
-        Object.keys(projectConfig).forEach(key => {
+        return Object.keys(projectConfig).every(key => {
             const field = key;
-            if (projectConfig[field] !== this.state.projectConfig[field]) {
-                return false;
-            }
+            return projectConfig[field] === this.state.projectConfig[field];
         });
-        return true;
     }
     async getIntermediateRepresentation(projectNodesAtLastDeploy) {
         const { intermediateRepresentation } = await translateForLocalDev({

package/lib/projects/projectProfiles.d.ts

@@ -2,8 +2,8 @@ import { type HsProfileFile } from '@hubspot/project-parsing-lib/profiles';
 import { ProjectConfig } from '../../types/Projects.js';
 export declare function logProfileHeader(profileName: string): void;
 export declare function logProfileFooter(profile: HsProfileFile, includeVariables?: boolean): void;
-export declare function loadProfile(projectConfig: ProjectConfig | null, projectDir: string | null, profileName: string): HsProfileFile | never;
-export declare function loadAndValidateProfile(projectConfig: ProjectConfig | null, projectDir: string | null, profileName: string, silent?: boolean): Promise<HsProfileFile | never>;
+export declare function loadProfile(projectConfig: ProjectConfig, projectDir: string, profileName: string): HsProfileFile | never;
+export declare function loadAndValidateProfile(projectConfig: ProjectConfig, projectDir: string, profileName: string, silent?: boolean): Promise<HsProfileFile | never>;
 type ValidateProjectForProfileOptions = {
     projectConfig: ProjectConfig;
     projectDir: string;

package/lib/projects/projectProfiles.js

@@ -25,9 +25,6 @@ export function logProfileFooter(profile, includeVariables = false) {
     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;

package/lib/projects/release.js

@@ -60,7 +60,7 @@ export async function resolveBuildId(accountId, projectName, buildOption, force)
 export async function validateBuildForRelease(accountId, projectName, buildId) {
     try {
         const { data: build } = await getBuildStatus(accountId, projectName, buildId);
-        return meetsMinimumPlatformVersion(build.platformVersion, PLATFORM_VERSIONS.v2027_03_BETA);
+        return meetsMinimumPlatformVersion(build.platformVersion, PLATFORM_VERSIONS.v2027_03);
     }
     catch (e) {
         if (isSpecifiedError(e, { statusCode: 404 })) {

package/lib/projects/uieLinting.js

@@ -170,9 +170,6 @@ export async function createEslintConfig(directory, platformVersion) {
     }
 }
 export async function getUieLintablePackageJsonLocations(projectConfig) {
-    if (!projectConfig.projectDir || !projectConfig.projectConfig?.srcDir) {
-        return [];
-    }
     const srcDirAbsolute = path.resolve(projectConfig.projectDir, projectConfig.projectConfig.srcDir);
     const uiePackageDirPrefixes = UIE_COMPONENTS.map(component => path.join(srcDirAbsolute, component.parentComponent
         ? Components[component.parentComponent].dir

package/lib/projects/validate.d.ts

@@ -0,0 +1,9 @@
+import { ProjectConfig } from '../../types/Projects.js';
+type ValidateProjectArgs = {
+    projectConfig: ProjectConfig;
+    projectDir: string;
+    derivedAccountId: number;
+    profile?: string;
+};
+export declare function validateProject({ projectConfig, projectDir, derivedAccountId, profile, }: ValidateProjectArgs): Promise<boolean>;
+export {};