implemented persistence

cmd/any2anexoj-cli/main.go

@@ -3,6 +3,7 @@ package main
 import (
 	"context"
 	"fmt"
+	"io"
 	"log/slog"
 	"net/http"
 	"os"
@@ -13,20 +14,19 @@ import (
 	"github.com/nmoniz/any2anexoj/internal/ofigi"
 	"github.com/nmoniz/any2anexoj/internal/trading212"
 	"github.com/spf13/pflag"
-	"golang.org/x/sync/errgroup"
 	"golang.org/x/text/language"
 )
 
 var (
 	// TODO: once we support more brokers or exchanges we should make this parameter required and
 	// remove/change default
-	platform = pflag.StringP("platform", "p", "trading212", "One of the supported platforms")
-	lang     = pflag.StringP("language", "l", language.Portuguese.String(), "The 2 letter language code")
-	debug    = pflag.BoolP("debug", "d", false, "Activate to log debug messages")
-	format   = pflag.StringP("format", "f", "table", "Output format: table or csv")
-	ofAPIKey = pflag.String("open-figi-api-key", "", "An OpenFIGI API key for faster report generation (better rate api rate limits)")
-	// TODO: improve documentation on selectors
+	platform  = pflag.StringP("platform", "p", "trading212", "One of the supported platforms")
+	lang      = pflag.StringP("language", "l", language.Portuguese.String(), "The 2 letter language code")
+	debug     = pflag.BoolP("debug", "d", false, "Activate to log debug messages")
+	format    = pflag.StringP("format", "f", "table", "Output format: table or csv")
+	ofAPIKey  = pflag.String("open-figi-api-key", "", "An OpenFIGI API key for faster report generation (better rate api rate limits)")
 	selectors = pflag.StringSlice("selectors", nil, "Only process entries that conform to all the selectors: code, assetCountry")
+	stateFile = pflag.String("state-file", "", "Path to a state file for incremental processing")
 )
 
 func main() {
@@ -39,12 +39,19 @@ func main() {
 	}
 }
 
+// run is the production entry point. It wires the CLI flags to runWithIO
+// using the process's actual stdin/stdout and installs OS-signal-driven
+// cancellation so a Ctrl-C cancels in-flight processing.
 func run(ctx context.Context) error {
 	ctx, cancel := signal.NotifyContext(ctx, os.Kill, os.Interrupt)
 	defer cancel()
+	return runWithIO(ctx, os.Stdin, os.Stdout)
+}
 
-	eg, ctx := errgroup.WithContext(ctx)
-
+// runWithIO is the testable core of the CLI. It reads broker records from
+// stdin, writes the formatted report to stdout, and optionally persists
+// incremental state to the path supplied via --state-file.
+func runWithIO(ctx context.Context, stdin io.Reader, stdout io.Writer) error {
 	logLevel := slog.LevelInfo
 	if *debug {
 		logLevel = slog.LevelDebug
@@ -59,11 +66,18 @@ func run(ctx context.Context) error {
 		return fmt.Errorf("--language flag is required")
 	}
 
-	reader, err := getReader(*platform, *ofAPIKey)
+	figiClient := ofigi.NewOpenFIGI(&http.Client{Timeout: 5 * time.Second}, *ofAPIKey)
+
+	reader, err := getReader(*platform, stdin, figiClient)
 	if err != nil {
 		return fmt.Errorf("getting reader: %w", err)
 	}
 
+	store, err := buildStore(*stateFile, *platform, figiClient)
+	if err != nil {
+		return err
+	}
+
 	writer := internal.NewAggregatorWriter()
 
 	selector, err := internal.ParseSelectors(*selectors)
@@ -71,34 +85,60 @@ func run(ctx context.Context) error {
 		return fmt.Errorf("parsing selectors: %w", err)
 	}
 
-	eg.Go(func() error {
-		return internal.BuildReport(ctx, reader, writer, internal.WithSelector(selector))
-	})
-
-	err = eg.Wait()
+	err = internal.BuildReport(
+		ctx,
+		reader,
+		writer,
+		internal.WithSelector(selector),
+		internal.WithStore(store),
+	)
 	if err != nil {
 		return err
 	}
 
 	switch *format {
 	case "csv":
-		return NewCSVWriter(os.Stdout).Render(writer)
+		return NewCSVWriter(stdout).Render(writer)
 	case "table":
 		loc, err := NewLocalizer(*lang)
 		if err != nil {
 			return fmt.Errorf("create localizer: %w", err)
 		}
-		NewPrettyPrinter(os.Stdout, loc).Render(writer)
+		NewPrettyPrinter(stdout, loc).Render(writer)
 		return nil
 	default:
 		return fmt.Errorf("unsupported format %q: must be table or csv", *format)
 	}
 }
 
-func getReader(platform string, ofAPIKey string) (internal.RecordReader, error) {
+// buildStore returns the Store implementation that BuildReport should use.
+// When --state-file is empty an EphemeralStore is used so behaviour is
+// identical to pre-persistence runs. Otherwise a JSON-backed FileStore is
+// returned, wired to a platform-specific RecordSerializer.
+func buildStore(stateFile, platform string, figi *ofigi.Client) (internal.Store, error) {
+	if stateFile == "" {
+		return internal.EphemeralStore{}, nil
+	}
+
+	var serializer internal.RecordSerializer
 	switch platform {
 	case "trading212":
-		return trading212.NewRecordReader(os.Stdin, ofigi.NewOpenFIGI(&http.Client{Timeout: 5 * time.Second}, ofAPIKey)), nil
+		serializer = trading212.NewRecordSerializer(figi)
+	default:
+		return nil, fmt.Errorf("unsupported platform for state persistence: %s", platform)
+	}
+
+	store, err := internal.NewFileStore(stateFile, platform, serializer)
+	if err != nil {
+		return nil, fmt.Errorf("creating file store: %w", err)
+	}
+	return store, nil
+}
+
+func getReader(platform string, r io.Reader, figi *ofigi.Client) (internal.RecordReader, error) {
+	switch platform {
+	case "trading212":
+		return trading212.NewRecordReader(r, figi), nil
 	default:
 		return nil, fmt.Errorf("unsupported platform: %s", platform)
 	}