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

package/lib/projects/deploy.js

@@ -0,0 +1,76 @@
+import { uiLogger } from '../ui/logger.js';
+import { commands } from '../../lang/en.js';
+import { PROJECT_ERROR_TYPES } from '../constants.js';
+import { deployProjectV1, deployProjectV2, } from '@hubspot/local-dev-lib/api/projects';
+import { pollDeployStatus } from './pollProjectBuildAndDeploy.js';
+export function validateBuildIdForDeploy(buildId, deployedBuildId, latestBuildId, projectName, accountId) {
+    if (Number(buildId) > latestBuildId) {
+        return commands.project.deploy.errors.buildIdDoesNotExist(accountId, buildId, projectName);
+    }
+    if (Number(buildId) === deployedBuildId) {
+        return commands.project.deploy.errors.buildAlreadyDeployed(accountId, buildId, projectName);
+    }
+    return true;
+}
+export function logDeployErrors(errorData) {
+    uiLogger.error(errorData.message);
+    errorData.errors.forEach(err => {
+        // This is how the pre-deploy check manifests itself in < 2025.2 projects
+        if (err.subCategory === PROJECT_ERROR_TYPES.DEPLOY_CONTAINS_REMOVALS) {
+            uiLogger.log(commands.project.deploy.errors.deployContainsRemovals(err.context.COMPONENT_NAME));
+        }
+        else {
+            uiLogger.log(err.message);
+        }
+    });
+}
+function handleBlockedDeploy(deployResp) {
+    const deployCanBeForced = deployResp.issues.every(issue => issue.blockingMessages.every(message => message.isWarning));
+    uiLogger.log('');
+    if (deployCanBeForced) {
+        uiLogger.warn(commands.project.deploy.errors.deployWarningsHeader);
+        uiLogger.log('');
+    }
+    else {
+        uiLogger.error(commands.project.deploy.errors.deployBlockedHeader);
+        uiLogger.log('');
+    }
+    deployResp.issues.forEach(issue => {
+        if (issue.blockingMessages.length > 0) {
+            issue.blockingMessages.forEach(message => {
+                uiLogger.log(commands.project.deploy.errors.deployIssueComponentWarning(issue.uid, issue.componentTypeName, message.message));
+            });
+        }
+        else {
+            uiLogger.log(commands.project.deploy.errors.deployIssueComponentGeneric(issue.uid, issue.componentTypeName));
+        }
+        uiLogger.log('');
+    });
+}
+export async function handleProjectDeploy(targetAccountId, projectName, buildId, isV2Project, force) {
+    let deployId;
+    if (isV2Project) {
+        const { data: deployResp } = await deployProjectV2(targetAccountId, projectName, buildId, force);
+        if (!deployResp || deployResp.buildResultType !== 'DEPLOY_QUEUED') {
+            if (deployResp?.buildResultType === 'DEPLOY_BLOCKED') {
+                handleBlockedDeploy(deployResp);
+            }
+            else {
+                uiLogger.error(commands.project.deploy.errors.deploy);
+            }
+            return;
+        }
+        deployId = deployResp.id;
+    }
+    else {
+        const response = await deployProjectV1(targetAccountId, projectName, buildId, force);
+        const { data: deployResp } = response;
+        if (!deployResp) {
+            uiLogger.error(commands.project.deploy.errors.deploy);
+            return;
+        }
+        deployId = deployResp.id;
+    }
+    const deployResult = await pollDeployStatus(targetAccountId, projectName, Number(deployId), buildId);
+    return deployResult;
+}

package/lib/projects/ensureProjectExists.d.ts

@@ -0,0 +1,11 @@
+import { Project } from '@hubspot/local-dev-lib/types/Project';
+export declare function ensureProjectExists(accountId: number, projectName: string, { forceCreate, allowCreate, noLogs, withPolling, uploadCommand, }?: {
+    forceCreate?: boolean | undefined;
+    allowCreate?: boolean | undefined;
+    noLogs?: boolean | undefined;
+    withPolling?: boolean | undefined;
+    uploadCommand?: boolean | undefined;
+}): Promise<{
+    projectExists: boolean;
+    project?: Project;
+}>;

package/lib/projects/ensureProjectExists.js

@@ -0,0 +1,89 @@
+import { createProject, fetchProject, } from '@hubspot/local-dev-lib/api/projects';
+import { isSpecifiedError } from '@hubspot/local-dev-lib/errors/index';
+import { DEFAULT_POLLING_DELAY } from '../constants.js';
+import { promptUser } from '../prompts/promptUtils.js';
+import { uiAccountDescription } from '../ui/index.js';
+import SpinniesManager from '../ui/SpinniesManager.js';
+import { logError, ApiErrorContext } from '../errorHandlers/index.js';
+import { lib } from '../../lang/en.js';
+import { uiLogger } from '../ui/logger.js';
+async function pollFetchProject(accountId, projectName) {
+    // Temporary solution for gating slowness. Retry on 403 statusCode
+    return new Promise((resolve, reject) => {
+        let pollCount = 0;
+        SpinniesManager.add('pollFetchProject', {
+            text: lib.projects.pollFetchProject.checkingProject(uiAccountDescription(accountId)),
+        });
+        const pollInterval = setInterval(async () => {
+            try {
+                const response = await fetchProject(accountId, projectName);
+                if (response && response.data) {
+                    SpinniesManager.remove('pollFetchProject');
+                    clearInterval(pollInterval);
+                    resolve(response);
+                }
+            }
+            catch (err) {
+                if (isSpecifiedError(err, {
+                    statusCode: 403,
+                    category: 'GATED',
+                    subCategory: 'BuildPipelineErrorType.PORTAL_GATED',
+                }) &&
+                    pollCount < 15) {
+                    pollCount += 1;
+                }
+                else {
+                    SpinniesManager.remove('pollFetchProject');
+                    clearInterval(pollInterval);
+                    reject(err);
+                }
+            }
+        }, DEFAULT_POLLING_DELAY);
+    });
+}
+export async function ensureProjectExists(accountId, projectName, { forceCreate = false, allowCreate = true, noLogs = false, withPolling = false, uploadCommand = false, } = {}) {
+    const accountIdentifier = uiAccountDescription(accountId);
+    try {
+        const { data: project } = withPolling
+            ? await pollFetchProject(accountId, projectName)
+            : await fetchProject(accountId, projectName);
+        return { projectExists: !!project, project };
+    }
+    catch (err) {
+        if (isSpecifiedError(err, { statusCode: 404 })) {
+            let shouldCreateProject = forceCreate;
+            if (allowCreate && !shouldCreateProject) {
+                const promptLangFunction = uploadCommand
+                    ? lib.projects.ensureProjectExists.createPromptUpload
+                    : lib.projects.ensureProjectExists.createPrompt;
+                const promptResult = await promptUser([
+                    {
+                        name: 'shouldCreateProject',
+                        message: promptLangFunction(projectName, accountIdentifier),
+                        type: 'confirm',
+                    },
+                ]);
+                shouldCreateProject = promptResult.shouldCreateProject;
+            }
+            if (shouldCreateProject) {
+                try {
+                    const { data: project } = await createProject(accountId, projectName);
+                    uiLogger.success(lib.projects.ensureProjectExists.createSuccess(projectName, accountIdentifier));
+                    return { projectExists: true, project };
+                }
+                catch (err) {
+                    logError(err, new ApiErrorContext({ accountId }));
+                    return { projectExists: false };
+                }
+            }
+            else {
+                if (!noLogs) {
+                    uiLogger.log(lib.projects.ensureProjectExists.notFound(projectName, accountIdentifier));
+                }
+                return { projectExists: false };
+            }
+        }
+        logError(err, new ApiErrorContext({ accountId }));
+        return { projectExists: false };
+    }
+}

package/lib/projects/localDev/AppDevModeInterface.d.ts

@@ -0,0 +1,41 @@
+import { AppIRNode } from '../../../types/ProjectComponents.js';
+import LocalDevState from './LocalDevState.js';
+import LocalDevLogger from './LocalDevLogger.js';
+type AppDevModeInterfaceConstructorOptions = {
+    localDevState: LocalDevState;
+    localDevLogger: LocalDevLogger;
+};
+declare class AppDevModeInterface {
+    localDevState: LocalDevState;
+    localDevLogger: LocalDevLogger;
+    _appNode?: AppIRNode | null;
+    marketplaceAppInstalls?: number;
+    private appInstallResolve?;
+    constructor(options: AppDevModeInterfaceConstructorOptions);
+    private getAppNodeFromProjectNodes;
+    private get appNode();
+    private get appData();
+    private set appData(value);
+    private isStaticAuthApp;
+    private isOAuthApp;
+    private isAutomaticallyInstallable;
+    private getAppInstallUrl;
+    private fetchAppData;
+    private checkMarketplaceAppInstalls;
+    private waitUntilAppIsInstalled;
+    private autoInstallStaticAuthApp;
+    private installAppOrOpenInstallUrl;
+    private checkTestAccountAppInstallation;
+    private validateOauthAppRedirectUrl;
+    private resolveAppInstallPromise;
+    private handleAppInstallSuccessDevServerMessage;
+    private handleAppInstallInitiatedDevServerMessage;
+    private handleAppInstallFailureDevServerMessage;
+    private onDevServerMessage;
+    private onChangeProjectNodes;
+    private removeStateListeners;
+    setup(): Promise<void>;
+    start(): Promise<void>;
+    cleanup(): Promise<void>;
+}
+export default AppDevModeInterface;

package/lib/projects/localDev/AppDevModeInterface.js

@@ -0,0 +1,337 @@
+import { fetchAppInstallationData } from '@hubspot/local-dev-lib/api/localDevAuth';
+import { fetchAppMetadataBySourceId, fetchPublicAppProductionInstallCounts, installStaticAuthAppOnTestAccount, } from '@hubspot/local-dev-lib/api/appsDev';
+import { getConfigAccountById } from '@hubspot/local-dev-lib/config';
+import { APP_AUTH_TYPES, APP_DISTRIBUTION_TYPES, APP_INSTALLATION_STATES, LOCAL_DEV_SERVER_MESSAGE_TYPES, } from '../../constants.js';
+import { EXIT_CODES } from '../../enums/exitCodes.js';
+import { isAppIRNode } from '../../projects/structure.js';
+import { uiLine } from '../../ui/index.js';
+import { logError } from '../../errorHandlers/index.js';
+import { PromptExitError } from '../../errors/PromptExitError.js';
+import { installAppAutoPrompt, installAppBrowserPrompt, } from '../../prompts/installAppPrompt.js';
+import { confirmPrompt } from '../../prompts/promptUtils.js';
+import { lib } from '../../../lang/en.js';
+import { uiLogger } from '../../ui/logger.js';
+import { getOauthAppInstallUrl, getStaticAuthAppInstallUrl, } from '../../app/urls.js';
+import { isDeveloperTestAccount, isSandbox } from '../../accountTypes.js';
+import SpinniesManager from '../../ui/SpinniesManager.js';
+import { isServerRunningAtUrl } from '../../http.js';
+class AppDevModeInterface {
+    localDevState;
+    localDevLogger;
+    _appNode;
+    marketplaceAppInstalls;
+    appInstallResolve;
+    constructor(options) {
+        this.localDevState = options.localDevState;
+        this.localDevLogger = options.localDevLogger;
+        if (!this.localDevState.targetProjectAccountId ||
+            !this.localDevState.projectConfig ||
+            !this.localDevState.projectDir) {
+            uiLogger.error(lib.LocalDevManager.failedToInitialize);
+            process.exit(EXIT_CODES.ERROR);
+        }
+    }
+    getAppNodeFromProjectNodes(projectNodes) {
+        return Object.values(projectNodes).find(isAppIRNode) || null;
+    }
+    // Assumes only one app per project
+    get appNode() {
+        if (this._appNode === undefined) {
+            this._appNode = this.getAppNodeFromProjectNodes(this.localDevState.projectNodes);
+        }
+        return this._appNode;
+    }
+    get appData() {
+        // These checks are primarily for type safety
+        // App data will never be accessed before being set
+        if (!this.appNode) {
+            uiLogger.log(lib.AppDevModeInterface.appDataNotFound);
+            process.exit(EXIT_CODES.ERROR);
+        }
+        const data = this.localDevState.getAppDataByUid(this.appNode.uid);
+        if (!data) {
+            uiLogger.log(lib.AppDevModeInterface.appDataNotFound);
+            process.exit(EXIT_CODES.ERROR);
+        }
+        return data;
+    }
+    set appData(appData) {
+        if (!this.appNode) {
+            return;
+        }
+        this.localDevState.setAppDataForUid(this.appNode.uid, appData);
+    }
+    isStaticAuthApp() {
+        return (this.appNode?.config.auth.type.toLowerCase() === APP_AUTH_TYPES.STATIC);
+    }
+    isOAuthApp() {
+        return (this.appNode?.config.auth.type.toLowerCase() === APP_AUTH_TYPES.OAUTH);
+    }
+    isAutomaticallyInstallable() {
+        const targetTestingAccount = getConfigAccountById(this.localDevState.targetTestingAccountId);
+        if (!targetTestingAccount) {
+            return false;
+        }
+        const isTestAccount = isDeveloperTestAccount(targetTestingAccount) ||
+            isSandbox(targetTestingAccount);
+        const hasCorrectParent = targetTestingAccount.parentAccountId ===
+            this.localDevState.targetProjectAccountId;
+        return isTestAccount && hasCorrectParent && this.isStaticAuthApp();
+    }
+    async getAppInstallUrl() {
+        if (this.appNode && this.isOAuthApp()) {
+            return getOauthAppInstallUrl({
+                targetAccountId: this.localDevState.targetTestingAccountId,
+                env: this.localDevState.env,
+                clientId: this.appData.clientId,
+                scopes: this.appNode.config.auth.requiredScopes,
+                redirectUrls: this.appNode.config.auth.redirectUrls,
+            });
+        }
+        return getStaticAuthAppInstallUrl({
+            targetAccountId: this.localDevState.targetTestingAccountId,
+            env: this.localDevState.env,
+            appId: this.appData.id,
+        });
+    }
+    async fetchAppData() {
+        SpinniesManager.add('fetchAppData', {
+            text: lib.AppDevModeInterface.fetchAppData.checking(this.appNode?.config.name || ''),
+        });
+        let appData;
+        try {
+            const { data } = await fetchAppMetadataBySourceId(this.localDevState.projectData.id, this.appNode.uid, this.localDevState.targetProjectAccountId);
+            appData = data;
+        }
+        catch (e) {
+            SpinniesManager.fail('fetchAppData', {
+                text: lib.AppDevModeInterface.fetchAppData.error,
+            });
+            logError(e);
+            process.exit(EXIT_CODES.ERROR);
+        }
+        if (!appData) {
+            return;
+        }
+        const { data: { uniquePortalInstallCount }, } = await fetchPublicAppProductionInstallCounts(appData.id, this.localDevState.targetProjectAccountId);
+        this.appData = {
+            id: appData.id,
+            clientId: appData.clientId,
+            name: appData.name,
+            installationState: APP_INSTALLATION_STATES.UNKNOWN,
+            scopeGroupIds: appData.scopeGroupIds,
+        };
+        this.marketplaceAppInstalls = uniquePortalInstallCount;
+    }
+    async checkMarketplaceAppInstalls() {
+        if (!this.marketplaceAppInstalls) {
+            return;
+        }
+        SpinniesManager.fail('fetchAppData', {
+            text: lib.AppDevModeInterface.fetchAppData.activeInstallations(this.appNode?.config.name || '', this.marketplaceAppInstalls),
+            failColor: 'yellow',
+        });
+        uiLine();
+        uiLogger.log(lib.LocalDevManager.activeInstallWarning.explanation);
+        uiLine();
+        const proceed = await confirmPrompt(lib.LocalDevManager.activeInstallWarning.confirmationPrompt, { defaultAnswer: false });
+        if (!proceed) {
+            process.exit(EXIT_CODES.SUCCESS);
+        }
+        this.localDevState.addUploadWarning(lib.AppDevModeInterface.defaultMarketplaceAppWarning(this.marketplaceAppInstalls));
+    }
+    async waitUntilAppIsInstalled(installUrl) {
+        uiLogger.log(lib.AppDevModeInterface.waitUntilAppIsInstalled.link(installUrl));
+        SpinniesManager.add('waitUntilAppIsInstalled', {
+            text: lib.AppDevModeInterface.waitUntilAppIsInstalled.waiting,
+        });
+        await new Promise(resolve => {
+            this.appInstallResolve = resolve;
+        });
+        SpinniesManager.succeed('waitUntilAppIsInstalled', {
+            text: lib.AppDevModeInterface.waitUntilAppIsInstalled.success(this.appNode?.config.name || '', this.localDevState.targetTestingAccountId),
+        });
+    }
+    async autoInstallStaticAuthApp() {
+        const shouldInstall = await installAppAutoPrompt();
+        if (!shouldInstall) {
+            uiLogger.log(lib.AppDevModeInterface.autoInstallDeclined);
+            process.exit(EXIT_CODES.SUCCESS);
+        }
+        uiLogger.log('');
+        SpinniesManager.add('autoInstallStaticAuthApp', {
+            text: lib.AppDevModeInterface.autoInstallStaticAuthApp.installing(this.appData.name, this.localDevState.targetTestingAccountId),
+        });
+        try {
+            await installStaticAuthAppOnTestAccount(this.appData.id, this.localDevState.targetTestingAccountId, this.appData.scopeGroupIds);
+            SpinniesManager.succeed('autoInstallStaticAuthApp', {
+                text: lib.AppDevModeInterface.autoInstallStaticAuthApp.success(this.appData.name, this.localDevState.targetTestingAccountId),
+            });
+            return true;
+        }
+        catch (e) {
+            SpinniesManager.fail('autoInstallStaticAuthApp', {
+                text: lib.AppDevModeInterface.autoInstallStaticAuthApp.error(this.appData.name, this.localDevState.targetTestingAccountId),
+                failColor: 'white',
+            });
+            return false;
+        }
+    }
+    async installAppOrOpenInstallUrl(isReinstall) {
+        if (this.isAutomaticallyInstallable()) {
+            const installSuccess = await this.autoInstallStaticAuthApp();
+            if (installSuccess) {
+                return;
+            }
+        }
+        const installUrl = await this.getAppInstallUrl();
+        await installAppBrowserPrompt(installUrl, isReinstall);
+        if (!isReinstall) {
+            await this.waitUntilAppIsInstalled(installUrl);
+        }
+    }
+    async checkTestAccountAppInstallation() {
+        if (!this.appNode) {
+            return {};
+        }
+        const { data: { isInstalledWithScopeGroups, previouslyAuthorizedScopeGroups }, } = await fetchAppInstallationData(this.localDevState.targetTestingAccountId, this.localDevState.projectId, this.appNode.uid, this.appNode.config.auth.requiredScopes, this.appNode.config.auth.optionalScopes);
+        const isReinstall = previouslyAuthorizedScopeGroups.length > 0;
+        if (isInstalledWithScopeGroups) {
+            this.appData = {
+                ...this.appData,
+                installationState: APP_INSTALLATION_STATES.INSTALLED,
+            };
+        }
+        else if (isReinstall) {
+            this.appData = {
+                ...this.appData,
+                installationState: APP_INSTALLATION_STATES.INSTALLED_WITH_OUTDATED_SCOPES,
+            };
+        }
+        else {
+            this.appData = {
+                ...this.appData,
+                installationState: APP_INSTALLATION_STATES.NOT_INSTALLED,
+            };
+        }
+        return { needsInstall: !isInstalledWithScopeGroups, isReinstall };
+    }
+    async validateOauthAppRedirectUrl() {
+        const redirectUrl = this.appNode?.config.auth.redirectUrls[0];
+        if (!redirectUrl) {
+            return;
+        }
+        const serverIsRunningAtRedirectUrl = await isServerRunningAtUrl(redirectUrl);
+        if (!serverIsRunningAtRedirectUrl) {
+            uiLogger.log('');
+            uiLogger.error(lib.AppDevModeInterface.oauthAppRedirectUrlError(redirectUrl));
+            process.exit(EXIT_CODES.ERROR);
+        }
+    }
+    resolveAppInstallPromise() {
+        if (this.appInstallResolve) {
+            this.appInstallResolve();
+            this.appInstallResolve = undefined;
+        }
+    }
+    handleAppInstallSuccessDevServerMessage() {
+        this.resolveAppInstallPromise();
+        this.appData = {
+            ...this.appData,
+            installationState: APP_INSTALLATION_STATES.INSTALLED,
+        };
+    }
+    handleAppInstallInitiatedDevServerMessage() {
+        this.resolveAppInstallPromise();
+    }
+    handleAppInstallFailureDevServerMessage() {
+        uiLogger.error(lib.AppDevModeInterface.installationFailed);
+        process.exit(EXIT_CODES.ERROR);
+    }
+    onDevServerMessage = async (message) => {
+        if (message === LOCAL_DEV_SERVER_MESSAGE_TYPES.WEBSOCKET_SERVER_CONNECTED) {
+            await this.checkTestAccountAppInstallation();
+        }
+        else if (message === LOCAL_DEV_SERVER_MESSAGE_TYPES.STATIC_AUTH_APP_INSTALL_SUCCESS) {
+            this.handleAppInstallSuccessDevServerMessage();
+        }
+        else if (message === LOCAL_DEV_SERVER_MESSAGE_TYPES.STATIC_AUTH_APP_INSTALL_FAILURE) {
+            this.handleAppInstallFailureDevServerMessage();
+        }
+        else if (message === LOCAL_DEV_SERVER_MESSAGE_TYPES.OAUTH_APP_INSTALL_INITIATED) {
+            this.handleAppInstallInitiatedDevServerMessage();
+        }
+    };
+    onChangeProjectNodes = (nodes) => {
+        const newAppNode = this.getAppNodeFromProjectNodes(nodes);
+        const oldDistribution = this.appNode?.config.distribution;
+        const newDistribution = newAppNode?.config.distribution;
+        const oldAuthType = this.appNode?.config.auth.type;
+        const newAuthType = newAppNode?.config.auth.type;
+        if (newDistribution?.toLowerCase() === APP_DISTRIBUTION_TYPES.MARKETPLACE &&
+            oldDistribution?.toLowerCase() !== APP_DISTRIBUTION_TYPES.MARKETPLACE) {
+            this.localDevState.addUploadWarning(lib.AppDevModeInterface.distributionChanged);
+        }
+        else if (newAuthType?.toLowerCase() === APP_AUTH_TYPES.OAUTH &&
+            oldAuthType?.toLowerCase() !== APP_AUTH_TYPES.OAUTH) {
+            this.localDevState.addUploadWarning(lib.AppDevModeInterface.authTypeChanged);
+        }
+    };
+    removeStateListeners() {
+        this.localDevState.removeListener('devServerMessage', this.onDevServerMessage);
+        this.localDevState.removeListener('projectNodes', this.onChangeProjectNodes);
+    }
+    async setup() {
+        if (!this.appNode) {
+            return;
+        }
+        try {
+            await this.fetchAppData();
+            if (this.appNode.config.distribution === APP_DISTRIBUTION_TYPES.MARKETPLACE) {
+                await this.checkMarketplaceAppInstalls();
+            }
+            const { needsInstall, isReinstall } = await this.checkTestAccountAppInstallation();
+            if (needsInstall) {
+                if (SpinniesManager.pick('fetchAppData')) {
+                    SpinniesManager.fail('fetchAppData', {
+                        text: lib.AppDevModeInterface.fetchAppData.notInstalled(this.appNode.config.name, this.localDevState.targetTestingAccountId),
+                        failColor: 'white',
+                    });
+                }
+                if (this.isOAuthApp()) {
+                    await this.validateOauthAppRedirectUrl();
+                }
+                this.localDevState.addListener('devServerMessage', this.onDevServerMessage);
+                await this.installAppOrOpenInstallUrl(isReinstall || false);
+            }
+            else {
+                if (SpinniesManager.pick('fetchAppData')) {
+                    SpinniesManager.succeed('fetchAppData', {
+                        text: lib.AppDevModeInterface.fetchAppData.success(this.appNode.config.name, this.localDevState.targetTestingAccountId),
+                    });
+                }
+                uiLogger.log('');
+            }
+        }
+        catch (e) {
+            if (e instanceof PromptExitError) {
+                throw e;
+            }
+            if (SpinniesManager.pick('fetchAppData')) {
+                SpinniesManager.fail('fetchAppData', {
+                    text: lib.AppDevModeInterface.fetchAppData.error,
+                    failColor: 'white',
+                });
+            }
+            logError(e);
+            process.exit(EXIT_CODES.ERROR);
+        }
+    }
+    async start() {
+        this.localDevState.addListener('projectNodes', this.onChangeProjectNodes);
+    }
+    async cleanup() {
+        this.removeStateListeners();
+    }
+}
+export default AppDevModeInterface;

package/lib/projects/localDev/DevServerManager.d.ts

@@ -0,0 +1,21 @@
+import LocalDevState from './LocalDevState.js';
+import LocalDevLogger from './LocalDevLogger.js';
+type DevServerManagerConstructorOptions = {
+    localDevState: LocalDevState;
+    logger: LocalDevLogger;
+};
+declare class DevServerManager {
+    private initialized;
+    private started;
+    private devServers;
+    constructor(options: DevServerManagerConstructorOptions);
+    private iterateDevServers;
+    setup(): Promise<void>;
+    start(): Promise<void>;
+    fileChange({ filePath, event, }: {
+        filePath: string;
+        event: string;
+    }): Promise<void>;
+    cleanup(): Promise<void>;
+}
+export default DevServerManager;

package/lib/projects/localDev/DevServerManager.js

@@ -0,0 +1,64 @@
+import AppDevModeInterface from './AppDevModeInterface.js';
+import { lib } from '../../../lang/en.js';
+import UIExtensionsDevModeInterface from './UIExtensionsDevModeInterface.js';
+class DevServerManager {
+    initialized;
+    started;
+    devServers;
+    constructor(options) {
+        this.initialized = false;
+        this.started = false;
+        const AppsDevServer = new AppDevModeInterface({
+            localDevState: options.localDevState,
+            localDevLogger: options.logger,
+        });
+        const UIExtensionsDevServer = new UIExtensionsDevModeInterface({
+            localDevState: options.localDevState,
+        });
+        this.devServers = [AppsDevServer, UIExtensionsDevServer];
+    }
+    async iterateDevServers(callback) {
+        await Promise.all(this.devServers.map(devServer => callback(devServer)));
+    }
+    async setup() {
+        for (const devServer of this.devServers) {
+            if (devServer.setup) {
+                // Run setup functions in order
+                await devServer.setup();
+            }
+        }
+        this.initialized = true;
+    }
+    async start() {
+        if (this.initialized) {
+            await this.iterateDevServers(async (serverInterface) => {
+                if (serverInterface.start) {
+                    await serverInterface.start();
+                }
+            });
+        }
+        else {
+            throw new Error(lib.DevServerManager.notInitialized);
+        }
+        this.started = true;
+    }
+    async fileChange({ filePath, event, }) {
+        if (this.started) {
+            this.iterateDevServers(async (serverInterface) => {
+                if (serverInterface.fileChange) {
+                    await serverInterface.fileChange(filePath, event);
+                }
+            });
+        }
+    }
+    async cleanup() {
+        if (this.started) {
+            await this.iterateDevServers(async (serverInterface) => {
+                if (serverInterface.cleanup) {
+                    await serverInterface.cleanup();
+                }
+            });
+        }
+    }
+}
+export default DevServerManager;

package/lib/projects/localDev/DevServerManager_DEPRECATED.d.ts

@@ -0,0 +1,40 @@
+import { ProjectConfig, ComponentTypes, Component } from '../../../types/Projects.js';
+type DevServerInterface = {
+    setup?: Function;
+    start?: (options: object) => Promise<void>;
+    fileChange?: (filePath: string, event: string) => Promise<void>;
+    cleanup?: () => Promise<void>;
+};
+type ComponentsByType = {
+    [key in ComponentTypes]?: {
+        [key: string]: Component;
+    };
+};
+declare class DevServerManager_DEPRECATED {
+    private initialized;
+    private started;
+    private componentsByType;
+    private devServers;
+    constructor();
+    iterateDevServers(callback: (serverInterface: DevServerInterface, compatibleComponents: {
+        [key: string]: Component;
+    }) => Promise<void>): Promise<void>;
+    arrangeComponentsByType(components: Component[]): ComponentsByType;
+    setup({ components, onUploadRequired, accountId, setActiveApp, }: {
+        components: Component[];
+        onUploadRequired: () => void;
+        accountId: number;
+        setActiveApp: (appUid: string | undefined) => Promise<void>;
+    }): Promise<void>;
+    start({ accountId, projectConfig, }: {
+        accountId: number;
+        projectConfig: ProjectConfig;
+    }): Promise<void>;
+    fileChange({ filePath, event, }: {
+        filePath: string;
+        event: string;
+    }): Promise<void>;
+    cleanup(): Promise<void>;
+}
+declare const Manager: DevServerManager_DEPRECATED;
+export default Manager;