intake/cmd/action.go

package cmd

import (
	"fmt"
	"log"
	"slices"
	"time"

	"github.com/Jaculabilis/intake/core"
	"github.com/spf13/cobra"
)

var actionCmd = &cobra.Command{
	Use:     "action --source name --action name {--item id | -- [argv]}",
	GroupID: sourceGroup.ID,
	Short:   "Manage and run source actions",
	Long: fmt.Sprintf(`Manage and run source actions on items.

A feed source is updated by the "fetch" action, which receives no input and
returns one JSON item per line on stdout. Other source actions are run on a
specific item, receiving that item on stdin and expecting that item, with any
modifications made by the action, on stdout.

Items declare support for an action by having an "action" key containing an
object with a key for every supported action. The value of that key may be
any arbitrary JSON value. Use --force to execute an unsupported action anyway,
though the action may fail if it operates on the item's action data.

The special action "on_create" is always run when an item is first returned
by a fetch. The item does not need to declare support for "on_create". This
action is not accessible through the web interface, so if you need to retry
the action, you need another action with the same command as "on_create".
If an item's "on_create" fails, the item is still created, but without any
changes from the "on_create", if any.

To test and execute "fetch" actions, use "intake fetch".

In a dry run, the item will be printed in the chosen format and not updated.

%s`, makeFormatHelpText()),
	Run: func(cmd *cobra.Command, args []string) {
		action(
			stringArg(cmd, "source"),
			stringArg(cmd, "action"),
			stringArg(cmd, "item"),
			getArgv(cmd, args),
			stringArg(cmd, "format"),
			stringArg(cmd, "timeout"),
			boolArg(cmd, "dry-run"),
			boolArg(cmd, "diff"),
			boolArg(cmd, "force"),
		)
	},
	DisableFlagsInUseLine: true,
}

func init() {
	rootCmd.AddCommand(actionCmd)

	actionCmd.Flags().StringP("source", "s", "", "Source to add action")
	actionCmd.MarkFlagRequired("source")
	actionCmd.Flags().StringP("action", "a", "", "Action name")
	actionCmd.MarkFlagRequired("action")
	actionCmd.PersistentFlags().StringP("item", "i", "", "Item to run action on")

	actionCmd.Flags().StringP("format", "f", "headlines", "Feed format for returned items")
	actionCmd.Flags().StringP("timeout", "t", core.DefaultTimeout.String(), "Timeout duration")
	actionCmd.Flags().BoolP("dry-run", "n", false, "Instead of updating the item, print it")
	actionCmd.Flags().Bool("diff", false, "Show which fields of the item changed")
	actionCmd.Flags().Bool("force", false, "Execute the action even if the item does not support it")
}

func action(
	source,
	action,
	itemId string,
	argv []string,
	format string,
	timeout string,
	dryRun,
	diff,
	force bool,
) {
	if source == "" {
		log.Fatal("error: --source is empty")
	}
	if action == "" {
		log.Fatal("error: --action is empty")
	}
	formatter := formatAs(format)
	duration, err := time.ParseDuration(timeout)
	if err != nil {
		log.Fatalf("error: invalid duration: %v", err)
	}

	db := openAndMigrateDb()

	if itemId == "" {
		if len(argv) > 0 {
			err := core.SetAction(db, source, action, argv)
			if err != nil {
				log.Fatalf("error: failed to set action: %v", err)
			}
			log.Printf("Defined action %s on source %s", action, source)
		} else {
			err := core.DeleteAction(db, source, action)
			if err != nil {
				log.Fatalf("error: failed to delete action: %v", err)
			}
			log.Printf("Deleted action %s from source %s", action, source)
		}
		return
	}

	state, envs, argv, err := core.GetSourceActionInputs(db, source, action)
	if err != nil {
		log.Fatalf("error: failed to load data for %s: %v", source, err)
	}

	item, err := core.GetItem(db, source, itemId)
	if err != nil {
		log.Fatalf("error: failed to get item: %v", err)
	}

	if item.Action[action] == nil {
		if force {
			log.Printf("warning: force-executing %s on %s/%s", action, source, itemId)
		} else {
			log.Fatalf("error: %s/%s does not support %s", source, itemId, action)
		}
	}

	newItem, newState, errItem, err := core.ExecuteItemAction(item, argv, envs, state, duration)
	if err != nil {
		core.AddErrorItem(db, errItem)
		log.Fatalf("error executing %s: %v", action, err)
	}

	if diff {
		if item.Title != newItem.Title {
			log.Printf("title: %s => %s", item.Title, newItem.Title)
		}
		if item.Author != newItem.Author {
			log.Printf("author: %s => %s", item.Author, newItem.Author)
		}
		if item.Body != newItem.Body {
			log.Printf("body: %s => %s", item.Body, newItem.Body)
		}
		if item.Link != newItem.Link {
			log.Printf("link: %s => %s", item.Link, newItem.Link)
		}
		if item.Time != newItem.Time {
			log.Printf("time: %d => %d", item.Time, newItem.Time)
		}
		if core.ItemsAreEqual(item, newItem) {
			log.Printf("no changes\n")
		}
		if !slices.Equal(state, newState) {
			log.Printf("state changed (%d => %d bytes)", len(state), len(newState))
		}
	}

	if dryRun {
		fmt.Println(formatter(newItem))
		return
	}

	if err = db.Transact(func(tx core.DB) error {
		if _err := core.UpdateItems(tx, []core.Item{newItem}); err != nil {
			return fmt.Errorf("failed to update item: %v", _err)
		}
		if _err := core.SetState(tx, source, newState); err != nil {
			return fmt.Errorf("failed to set state for %s: %v", source, _err)
		}
		return nil
	}); err != nil {
		log.Fatalf("error: %v", err)
	}
}