knowledge-governance/cmd/test-publication-seed/main.go

package main

import (
	"context"
	"encoding/json"
	"errors"
	"flag"
	"fmt"
	"io"
	"log"
	"os"
	"strconv"
	"time"

	"github.com/jackc/pgx/v5/pgxpool"

	postgresstore "knowledge-governance/internal/platform/postgres"
	"knowledge-governance/internal/platform/spool"
)

type manualSeeder interface {
	SeedManualPublication(context.Context, postgresstore.ManualPublicationSeedRequest) (postgresstore.ManualPublicationSeedResult, error)
}

type seedConfig struct {
	SpoolRoot string
	SpoolRef  string
	Format    string
	Title     string
	TestKBID  string
	MaxBytes  int64
	Now       time.Time
}

func main() {
	if err := run(context.Background(), os.Args[1:], os.Getenv, os.Stdout); err != nil {
		log.Fatal(err)
	}
}

func run(ctx context.Context, args []string, getenv func(string) string, output io.Writer) error {
	flags := flag.NewFlagSet("test-publication-seed", flag.ContinueOnError)
	flags.SetOutput(io.Discard)
	spoolRef := flags.String("spool-ref", "", "opaque relative spool reference")
	format := flags.String("format", "md", "validated artifact format")
	title := flags.String("title", "", "safe display title")
	if err := flags.Parse(args); err != nil {
		return errors.New("invalid seed arguments")
	}
	databaseURL := getenv("DATABASE_URL")
	spoolRoot := getenv("GOVERNANCE_SPOOL_ROOT")
	if spoolRoot == "" {
		spoolRoot = "/var/lib/governance/spool"
	}
	testKBID := getenv("TEST_WEKNORA_KB_ID")
	maxBytes := int64(50 * 1024 * 1024)
	if raw := getenv("TEST_WEKNORA_MAX_UPLOAD_BYTES"); raw != "" {
		parsed, err := strconv.ParseInt(raw, 10, 64)
		if err != nil || parsed <= 0 || parsed > 50*1024*1024 {
			return errors.New("invalid TEST_WEKNORA_MAX_UPLOAD_BYTES")
		}
		maxBytes = parsed
	}
	if databaseURL == "" || testKBID == "" || *spoolRef == "" || *title == "" {
		return errors.New("DATABASE_URL, TEST_WEKNORA_KB_ID, --spool-ref and --title are required")
	}
	pool, err := pgxpool.New(ctx, databaseURL)
	if err != nil {
		return errors.New("open governance database")
	}
	defer pool.Close()
	if err := pool.Ping(ctx); err != nil {
		return errors.New("connect governance database")
	}
	if err := postgresstore.ApplyMigrations(ctx, pool); err != nil {
		return errors.New("apply governance migrations")
	}
	result, err := seedFromSpool(ctx, postgresstore.NewStore(pool), seedConfig{
		SpoolRoot: spoolRoot,
		SpoolRef:  *spoolRef,
		Format:    *format,
		Title:     *title,
		TestKBID:  testKBID,
		MaxBytes:  maxBytes,
		Now:       time.Now().UTC(),
	})
	if err != nil {
		return err
	}
	return json.NewEncoder(output).Encode(result)
}

func seedFromSpool(ctx context.Context, store manualSeeder, config seedConfig) (postgresstore.ManualPublicationSeedResult, error) {
	if store == nil {
		return postgresstore.ManualPublicationSeedResult{}, errors.New("manual publication store is required")
	}
	expectation, err := spool.InspectVerified(config.SpoolRoot, config.SpoolRef, config.Format, config.MaxBytes)
	if err != nil {
		return postgresstore.ManualPublicationSeedResult{}, errors.New("inspect manual spool artifact")
	}
	mime, ok := mimeForFormat(config.Format)
	if !ok {
		return postgresstore.ManualPublicationSeedResult{}, errors.New("unsupported manual publication format")
	}
	result, err := store.SeedManualPublication(ctx, postgresstore.ManualPublicationSeedRequest{
		TestKBID:        config.TestKBID,
		Title:           config.Title,
		SHA256:          expectation.SHA256,
		SizeBytes:       expectation.SizeBytes,
		MIME:            mime,
		ValidatedFormat: expectation.Format,
		LocalSpoolRef:   expectation.RelativeRef,
		Now:             config.Now,
	})
	if err != nil {
		return postgresstore.ManualPublicationSeedResult{}, fmt.Errorf("seed manual publication: %w", err)
	}
	return result, nil
}

func mimeForFormat(format string) (string, bool) {
	mimes := map[string]string{
		"md": "text/markdown", "txt": "text/plain", "csv": "text/csv", "json": "application/json",
		"pdf": "application/pdf", "docx": "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
		"xlsx": "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
		"pptx": "application/vnd.openxmlformats-officedocument.presentationml.presentation",
		"doc":  "application/msword", "xls": "application/vnd.ms-excel", "ppt": "application/vnd.ms-powerpoint",
	}
	value, ok := mimes[format]
	return value, ok
}