@sprucelabs/spruce-cli/build/features/ActionFactory.js

Command line interface for building Spruce skills.

"use strict";
var __importDefault = (this && this.__importDefault) || function (mod) {
    return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
const spruce_skill_utils_1 = require("@sprucelabs/spruce-skill-utils");
const spruce_skill_utils_2 = require("@sprucelabs/spruce-skill-utils");
const SpruceError_1 = __importDefault(require("../errors/SpruceError"));
const OverrideActionDecorator_1 = __importDefault(require("./OverrideActionDecorator"));
class ActionFactory {
    actionOptions;
    blockedCommands;
    optionOverrides;
    static overrides = {};
    constructor(options) {
        const { blockedCommands, optionOverrides, ...actionOptions } = options;
        this.actionOptions = actionOptions;
        this.blockedCommands = blockedCommands;
        this.optionOverrides = optionOverrides;
    }
    Action(options) {
        const { featureCode, actionCode, actionExecuter, featureInstaller } = options;
        const feature = featureInstaller.getFeature(featureCode);
        if (!feature.actionsDir) {
            throw new Error(`Your ${featureCode} features needs \`public actionsDir = diskUtil.resolvePath(__dirname, 'actions')\``);
        }
        let Class;
        let originalError;
        const key = ActionFactory.overrideKey(featureCode, actionCode);
        if (ActionFactory.overrides[key]) {
            Class = ActionFactory.overrides[key];
        }
        else {
            const classPath = spruce_skill_utils_2.diskUtil.resolvePath(feature.actionsDir, `${spruce_skill_utils_1.namesUtil.toPascal(actionCode)}Action`);
            try {
                Class = require(classPath).default;
            }
            catch (err) {
                originalError = err;
            }
        }
        //@ts-ignore
        if (!Class) {
            throw new SpruceError_1.default({
                code: 'GENERIC',
                friendlyMessage: `I could not find any action named '${actionCode}' for the ${feature.code} feature. Make sure it's the default export and extends AbstractAction.`,
                originalError,
            });
        }
        const action = new Class({
            ...this.actionOptions,
            actionExecuter,
            parent: feature,
            featureInstaller,
        });
        if (!action) {
            throw new SpruceError_1.default({
                code: 'GENERIC',
                friendlyMessage: `I could not instantiate ${actionCode} action on ${feature.code} feature.`,
            });
        }
        if (!action.execute) {
            throw new SpruceError_1.default({
                code: 'GENERIC',
                friendlyMessage: `It looks like the ${feature.code} feature's '${actionCode}' action does not properly extend AbstractAction.`,
            });
        }
        const actionDecorator = new OverrideActionDecorator_1.default({
            action,
            feature,
            blockedCommands: this.blockedCommands,
            optionOverrides: this.optionOverrides,
            ui: this.actionOptions.ui,
            actionCode,
        });
        return actionDecorator;
    }
    static setActionClass(featureCode, action, ExecuteTrackingAction) {
        this.overrides[ActionFactory.overrideKey(featureCode, action)] =
            ExecuteTrackingAction;
    }
    static overrideKey(featureCode, action) {
        return `${featureCode}${action}`;
    }
    static clearActionOverrides() {
        this.overrides = {};
    }
}
exports.default = ActionFactory;
//# sourceMappingURL=ActionFactory.js.map