// Code generated from user_registration.flowdsl.yaml. DO NOT EDIT.
// Source: backend/flows/user_registration.flowdsl.yaml
// Generated: 2026-04-10T11:30:00Z
package flows

import (
    "context"
    "time"
    "github.com/redelay/go-framework/flowdsl"
)

// UserRegistrationFlowNodes holds all node handlers for the user_registration flow.
// Every field must be set — the compiler enforces it at construction time.
type UserRegistrationFlowNodes struct {
    // source: receives POST /register
    ReceiveRegistration flowdsl.SourceHandler

    // transform: validates email, password, account_type
    ValidateRegistrationInput flowdsl.RouterHandler // valid → continue, invalid → reject

    // router: routes by account_type (developer / community / customer)
    RouteRegistrationByType flowdsl.RouterHandler

    // action: creates core user + community profile in MongoDB
    CreateUserAccount flowdsl.NodeHandler

    // action: queues verification email via email.send event
    SendVerificationEmail flowdsl.NodeHandler

    // publish: emits users.registered to Kafka
    PublishUserRegistered flowdsl.PublishHandler

    // terminal: returns 400 with validation errors
    RejectInvalidRegistration flowdsl.TerminalHandler
}

// RegisterUserRegistrationFlow wires the user_registration flow using the provided handlers.
// Edge delivery modes are compiled in from the diagram — changing the YAML regenerates this function.
func RegisterUserRegistrationFlow(bus flowdsl.EventBus, nodes UserRegistrationFlowNodes) {
    // Edge: RegistrationSubmitted → ValidateRegistration [direct]
    // Delivery: in-process, microsecond latency, no durability
    // (triggered externally by the HTTP handler calling nodes.ReceiveRegistration)

    // Edge: ValidateRegistration.valid → RouteByAccountType [direct]
    // Edge: ValidateRegistration.invalid → RejectInvalidRegistration [direct]
    // These are handled by the RouterHandler return value (port name)

    // Edge: RouteByAccountType.* → CreateUserAccount [durable]
    // Delivery: MongoDB-backed packet, retry x3, exponential backoff 2s
    // IdempotencyKey: {{payload.email}}-register
    bus.Subscribe(flowdsl.DurableConsumer{
        Topic:          "flow.user_registration.create_account",
        GroupID:        "flow.user_registration",
        IdempotencyKey: func(p map[string]any) string {
            return fmt.Sprintf("%v-register", p["email"])
        },
        RetryPolicy: flowdsl.RetryPolicy{
            MaxAttempts:  3,
            Backoff:      flowdsl.ExponentialBackoff,
            InitialDelay: 2 * time.Second,
        },
        Handler: func(ctx context.Context, packet map[string]any) error {
            out, err := nodes.CreateUserAccount(ctx, flowdsl.NodeInput{Packet: packet})
            if err != nil { return err }
            return bus.Publish(ctx, "flow.user_registration.send_verification", out.Packet("out"))
        },
    })

    // Edge: CreateUserAccount → SendVerificationEmail [durable, retry x3]
    bus.Subscribe(flowdsl.DurableConsumer{
        Topic:   "flow.user_registration.send_verification",
        GroupID: "flow.user_registration",
        RetryPolicy: flowdsl.RetryPolicy{MaxAttempts: 3, Backoff: flowdsl.ExponentialBackoff, InitialDelay: 2 * time.Second},
        Handler: func(ctx context.Context, packet map[string]any) error {
            out, err := nodes.SendVerificationEmail(ctx, flowdsl.NodeInput{Packet: packet})
            if err != nil { return err }
            return bus.Publish(ctx, "flow.user_registration.publish_registered", out.Packet("out"))
        },
    })

    // Edge: SendVerificationEmail → PublishUserRegistered [stream, topic: users.registered]
    bus.Subscribe(flowdsl.DurableConsumer{
        Topic:   "flow.user_registration.publish_registered",
        GroupID: "flow.user_registration",
        Handler: func(ctx context.Context, packet map[string]any) error {
            return nodes.PublishUserRegistered(ctx, flowdsl.NodeInput{Packet: packet}, "users.registered")
        },
    })
}

// go-framework/modules/module.go (new interface)

// FlowNodeProvider is implemented by modules that register FlowDSL node handlers.
// The generated XxxFlowNodes struct is populated from these registrations.
type FlowNodeProvider interface {
    // FlowNodes returns all operationId → handler mappings this module provides.
    // Called at startup by flows.RegisterAll().
    FlowNodes() map[string]flowdsl.AnyHandler
}

// backend/modules/community/flows.go

// FlowNodes implements modules.FlowNodeProvider.
func (m *Module) FlowNodes() map[string]flowdsl.AnyHandler {
    return map[string]flowdsl.AnyHandler{
        "receive_registration":          flowdsl.Source(m.flowReceiveRegistration),
        "validate_registration_input":   flowdsl.Router(m.flowValidateRegistration),
        "route_registration_by_type":    flowdsl.Router(m.flowRouteByAccountType),
        "create_user_account":           flowdsl.Node(m.flowCreateUserAccount),
        "send_verification_email":       flowdsl.Node(m.flowSendVerificationEmail),
        "publish_user_registered":       flowdsl.Publish(m.flowPublishUserRegistered),
        "reject_invalid_registration":   flowdsl.Terminal(m.flowRejectInvalidRegistration),
    }
}

// flowCreateUserAccount wraps m.Service.Register — same logic as the HTTP handler,
// different input adapter (NodeInput instead of http.Request).
func (m *Module) flowCreateUserAccount(ctx context.Context, in flowdsl.NodeInput) (flowdsl.NodeOutput, error) {
    var req CommunityRegisterInput
    if err := in.Decode(&req); err != nil {
        return flowdsl.NodeOutput{}, err
    }
    member, user, err := m.Service.Register(ctx, &req)
    if err != nil {
        return flowdsl.NodeOutput{}, err
    }
    return flowdsl.Out("out", map[string]any{
        "id":           member.GetID().Hex(),
        "email":        user.Email,
        "account_type": string(member.AccountType),
    }), nil
}

// backend/flows/gen/register_all_gen.go  ← generated
package flows

func RegisterAll(bus flowdsl.EventBus, reg *modules.Registry) {
    // Collect all node handlers from FlowNodeProvider modules
    nodes := flowdsl.BuildNodeRegistry(reg)

    RegisterUserRegistrationFlow(bus, UserRegistrationFlowNodes{
        ReceiveRegistration:        nodes.Require("receive_registration"),
        ValidateRegistrationInput:  nodes.RequireRouter("validate_registration_input"),
        RouteRegistrationByType:    nodes.RequireRouter("route_registration_by_type"),
        CreateUserAccount:          nodes.Require("create_user_account"),
        SendVerificationEmail:      nodes.Require("send_verification_email"),
        PublishUserRegistered:      nodes.RequirePublish("publish_user_registered"),
        RejectInvalidRegistration:  nodes.RequireTerminal("reject_invalid_registration"),
    })

    RegisterModuleSubmissionFlow(bus, ModuleSubmissionFlowNodes{ ... })
    RegisterEmailNotificationFlow(bus, EmailNotificationFlowNodes{ ... })
    // ...
}

func main() {
    inst, srv, err := server.Default()
    if err != nil { log.Fatal(err) }

    // Wire all FlowDSL flows after module startup
    if err := inst.AfterStart(func(ctx context.Context) error {
        return flows.RegisterAll(inst.EventBus, inst.Modules)
    }); err != nil {
        log.Fatal(err)
    }

    if err := app.Run(inst, srv); err != nil { log.Fatal(err) }
}