knowledge-governance/internal/workflows/testweknora/remove.go

package testweknora

import (
	"context"
	"errors"
	"net/http"
	"time"

	"knowledge-governance/internal/jobs"
	postgresstore "knowledge-governance/internal/platform/postgres"
	"knowledge-governance/internal/platform/weknora"
)

var (
	ErrInvalidRemoveJobPayload = errors.New("test_remove_invalid_payload")
	ErrRemoveRemoteFailed      = errors.New("test_remove_remote_failed")
	ErrRemoveRemoteIdentity    = errors.New("test_remove_remote_identity_invalid")
	ErrRemovePending           = errors.New("test_remove_pending")
	ErrRemoveStateConflict     = errors.New("test_remove_state_conflict")
)

type RemoveStore interface {
	LoadPublicationForRemoval(context.Context, string) (postgresstore.PublicationForRemoval, error)
	RecordRemovalCompleted(context.Context, string, time.Time) error
	RecordRemovalFailure(context.Context, string, string, time.Time) error
}

type RemoveClient interface {
	GetKnowledge(context.Context, string) (weknora.Knowledge, error)
	DeleteKnowledge(context.Context, string) error
}

type RemoveHandlerConfig struct {
	Store  RemoveStore
	Client RemoveClient
	Now    func() time.Time
}

type RemoveHandler struct {
	store  RemoveStore
	client RemoveClient
	now    func() time.Time
}

type removePayload struct {
	PublicationID string `json:"publication_id"`
}

func NewRemoveHandler(config RemoveHandlerConfig) (*RemoveHandler, error) {
	if config.Store == nil || config.Client == nil {
		return nil, errors.New("invalid test removal handler configuration")
	}
	if config.Now == nil {
		config.Now = time.Now
	}
	return &RemoveHandler{store: config.Store, client: config.Client, now: config.Now}, nil
}

func (handler *RemoveHandler) Handle(ctx context.Context, job jobs.Job) error {
	var payload removePayload
	if err := decodeStrictJSON(job.Payload, &payload); err != nil || payload.PublicationID == "" {
		return jobs.Permanent(jobs.ErrCodeHandlerFallback, ErrInvalidRemoveJobPayload)
	}
	candidate, err := handler.store.LoadPublicationForRemoval(ctx, payload.PublicationID)
	if err != nil {
		return ErrRemoveStateConflict
	}
	knowledge, err := handler.client.GetKnowledge(ctx, candidate.KnowledgeID)
	if isNotFound(err) {
		return handler.complete(ctx, candidate.ID)
	}
	if err != nil {
		return ErrRemoveRemoteFailed
	}
	if knowledge.ID != candidate.KnowledgeID || knowledge.KnowledgeBaseID != candidate.TestKBID {
		return handler.failClosed(ctx, candidate.ID, "removal_identity_invalid")
	}
	if err := handler.client.DeleteKnowledge(ctx, candidate.KnowledgeID); err != nil {
		if isNotFound(err) {
			return handler.complete(ctx, candidate.ID)
		}
		if !weknora.IsRetryable(err) {
			return handler.failClosed(ctx, candidate.ID, "removal_remote_rejected")
		}
		return ErrRemoveRemoteFailed
	}
	knowledge, err = handler.client.GetKnowledge(ctx, candidate.KnowledgeID)
	if isNotFound(err) {
		return handler.complete(ctx, candidate.ID)
	}
	if err != nil {
		return ErrRemoveRemoteFailed
	}
	if knowledge.ID != candidate.KnowledgeID || knowledge.KnowledgeBaseID != candidate.TestKBID {
		return handler.failClosed(ctx, candidate.ID, "removal_identity_invalid")
	}
	return ErrRemovePending
}

func (handler *RemoveHandler) complete(ctx context.Context, publicationID string) error {
	if err := handler.store.RecordRemovalCompleted(ctx, publicationID, handler.now()); err != nil {
		return ErrRemoveStateConflict
	}
	return nil
}

func (handler *RemoveHandler) failClosed(ctx context.Context, publicationID, code string) error {
	if err := handler.store.RecordRemovalFailure(ctx, publicationID, code, handler.now()); err != nil {
		return ErrRemoveStateConflict
	}
	return nil
}

func isNotFound(err error) bool {
	var httpErr *weknora.HTTPError
	return errors.As(err, &httpErr) && httpErr.StatusCode == http.StatusNotFound
}