Method runCommand

src/core/superstate/commands.ts:964–1023

(action: string, instance: ActionInstance)

    }

    public async runCommand(action: string, instance: ActionInstance): Promise<ActionInstance> {
        const uri = parseURI(action);
        
        if (uri.authority !== '$api') {
            const command = this.commandForAction(action);
            if (!command) {
                return {...instance, error: new Error(`Command not found for action: ${action}`)};
            }

            let newInstance = instance;
            try {
                if (command.schema.type === 'actions') {
                    newInstance = await runActionString(this.superstate, command.code || "", instance);
                } else if (command.schema.type === 'script') {
                    newInstance.result = await executeCode(command.code, {...instance.instanceProps, $prev: instance.result});
                } else if (command.schema.type === 'formula') {
                    newInstance.result = runFormulaWithContext(
                        this.superstate.formulaContext,
                        this.superstate.pathsIndex,
                        this.superstate.spacesMap,
                        command.code,
                        command.fields.reduce((p, c) => ({ ...p, [c.name]: c }), {$prev: instance.result}),
                        instance.instanceProps
                    );
                }
            } catch (e) {
                newInstance.error = e;
            }
            return newInstance;
        }
        
        const command = this.commandForAction(action);
        
        if (!command) {
            return {...instance, error: new Error(`Command not found for action: ${action}`)};
        }
        
        let newInstance = instance;
        let result;
        
        try {
            if (command.schema.type === 'api') {
                const [namespace, method] = command.schema.id.split('.');
                const api = this.superstate.api as unknown as Record<string, any>;
                const namespaceMethods = api[namespace];
                
                if (namespaceMethods && typeof namespaceMethods[method] === 'function') {
                    result = await namespaceMethods[method](...command.fields.map(f => instance.instanceProps[f.name]));
                }
            }
        } catch (e) {
            newInstance.error = e;
        }
        
        if (command.schema.type === 'api' && result !== undefined) {
            newInstance = {...newInstance, result};
        }