@salesforce/plugin-org/lib/commands/org/open.js

Commands to interact with Salesforce orgs

/*
 * Copyright (c) 2020, salesforce.com, inc.
 * All rights reserved.
 * Licensed under the BSD 3-Clause license.
 * For full license text, see LICENSE.txt file in the repo root or https://opensource.org/licenses/BSD-3-Clause
 */
import path from 'node:path';
import { Flags, loglevel, orgApiVersionFlagWithDeprecations, requiredOrgFlagWithDeprecations, } from '@salesforce/sf-plugins-core';
import { Messages } from '@salesforce/core';
import { MetadataResolver } from '@salesforce/source-deploy-retrieve';
import { env } from '@salesforce/kit';
import { buildFrontdoorUrl } from '../../shared/orgOpenUtils.js';
import { OrgOpenCommandBase } from '../../shared/orgOpenCommandBase.js';
Messages.importMessagesDirectoryFromMetaUrl(import.meta.url);
const messages = Messages.loadMessages('@salesforce/plugin-org', 'open');
const sharedMessages = Messages.loadMessages('@salesforce/plugin-org', 'messages');
export class OrgOpenCommand extends OrgOpenCommandBase {
    static summary = messages.getMessage('summary');
    static description = messages.getMessage('description');
    static examples = messages.getMessages('examples');
    static aliases = ['force:org:open', 'force:source:open'];
    static deprecateAliases = true;
    static flags = {
        ...OrgOpenCommandBase.flags,
        'target-org': requiredOrgFlagWithDeprecations,
        'api-version': orgApiVersionFlagWithDeprecations,
        private: Flags.boolean({
            summary: messages.getMessage('flags.private.summary'),
            exclusive: ['url-only', 'browser'],
        }),
        browser: Flags.option({
            char: 'b',
            summary: messages.getMessage('flags.browser.summary'),
            options: ['chrome', 'edge', 'firefox'], // These are ones supported by "open" package
            exclusive: ['url-only', 'private'],
        })(),
        path: Flags.string({
            char: 'p',
            summary: messages.getMessage('flags.path.summary'),
            env: 'FORCE_OPEN_URL',
            exclusive: ['source-file'],
            parse: (input) => Promise.resolve(encodeURIComponent(decodeURIComponent(input))),
        }),
        'url-only': Flags.boolean({
            char: 'r',
            summary: messages.getMessage('flags.url-only.summary'),
            aliases: ['urlonly'],
            deprecateAliases: true,
        }),
        loglevel,
        'source-file': Flags.file({
            char: 'f',
            aliases: ['sourcefile'],
            exclusive: ['path'],
            deprecateAliases: true,
            summary: messages.getMessage('flags.source-file.summary'),
        }),
    };
    async run() {
        this.warn(sharedMessages.getMessage('BehaviorChangeWarning'));
        const { flags } = await this.parse(OrgOpenCommand);
        this.org = flags['target-org'];
        this.connection = this.org.getConnection(flags['api-version']);
        const singleUseEnvVar = env.getBoolean('SF_SINGLE_USE_ORG_OPEN_URL');
        const singleUseMode = singleUseEnvVar ? singleUseEnvVar : !(flags['url-only'] || this.jsonEnabled());
        const [frontDoorUrl, retUrl] = await Promise.all([
            buildFrontdoorUrl(this.org, this.connection, singleUseMode),
            flags['source-file'] ? generateFileUrl(flags['source-file'], this.connection) : flags.path,
        ]);
        return this.openOrgUI(flags, frontDoorUrl, retUrl);
    }
}
const generateFileUrl = async (file, conn) => {
    try {
        const metadataResolver = new MetadataResolver();
        const components = metadataResolver.getComponentsFromPath(file);
        const typeName = components[0]?.type?.name;
        switch (typeName) {
            case 'Bot':
                return `AiCopilot/copilotStudio.app#/copilot/builder?copilotId=${await botFileNameToId(conn, file)}`;
            case 'ApexPage':
                return `/apex/${path.basename(file).replace('.page-meta.xml', '').replace('.page', '')}`;
            case 'Flow':
                return `/builder_platform_interaction/flowBuilder.app?flowId=${await flowFileNameToId(conn, file)}`;
            case 'FlexiPage':
                return `/visualEditor/appBuilder.app?pageId=${await flexiPageFilenameToId(conn, file)}`;
            default:
                return 'lightning/setup/FlexiPageList/home';
        }
    }
    catch (error) {
        if (error instanceof Error && error.name === 'FlowIdNotFoundError') {
            throw error;
        }
        return 'lightning/setup/FlexiPageList/home';
    }
};
const botFileNameToId = async (conn, filePath) => (await conn.singleRecordQuery(`SELECT id FROM BotDefinition WHERE DeveloperName='${path.basename(filePath, '.bot-meta.xml')}'`)).Id;
/** query flexipage via toolingPAI to get its ID (starts with 0M0) */
const flexiPageFilenameToId = async (conn, filePath) => (await conn.singleRecordQuery(`SELECT id FROM flexipage WHERE DeveloperName='${path.basename(filePath, '.flexipage-meta.xml')}'`, { tooling: true })).Id;
/** query the rest API to turn a flow's filepath into a FlowId  (starts with 301) */
const flowFileNameToId = async (conn, filePath) => {
    try {
        const flow = await conn.singleRecordQuery(`SELECT DurableId FROM FlowVersionView WHERE FlowDefinitionView.ApiName = '${path.basename(filePath, '.flow-meta.xml')}' ORDER BY VersionNumber DESC LIMIT 1`);
        return flow.DurableId;
    }
    catch (error) {
        throw messages.createError('FlowIdNotFound', [filePath]);
    }
};
//# sourceMappingURL=open.js.map