authentication

type API struct {
	Options    *Options
	Endpoints  []*server.Endpoint
	DB         database.DB
	Controller *core.Controller
	// contains filtered or unexported fields
}

type AccountCreateInput struct {
	Meta                 codec.Meta             `json:"meta"`
	Username             string                 `json:"username"`
	Password             string                 `json:"password"`
	PasswordConfirmation string                 `json:"password_confirmation"`
	Attributes           map[string]interface{} `json:"attributes"`
}

type AccountGetterHandler interface {
	HandleGetAccount(ctx context.Context, db database.DB, account auth.Account) error
}

type AccountRegisterHandler interface {
	HandleRegisterAccount(ctx context.Context, db database.DB, options *RegisterAccountOptions) error
}

type AfterAccountRegistrar interface {
	AfterRegisterAccount(ctx context.Context, db database.DB, options *RegisterAccountOptions) error
}

type AfterFailedLoginer interface {
	AfterFailedLogin(ctx context.Context, db database.DB, options *LoginOptions) error
}

type AfterLoginer interface {
	AfterLogin(ctx context.Context, db database.DB, options *LoginOptions) error
}

type BeforeAccountRegistrar interface {
	BeforeRegisterAccount(ctx context.Context, db database.DB, options *RegisterAccountOptions) error
}

type BeforeLoginer interface {
	BeforeLogin(ctx context.Context, db database.DB, options *LoginOptions) error
}

type CheckUsernameHandler interface {
	HandleCheckUsername(ctx context.Context, db database.DB, account auth.Account) error
}

type DefaultHandler struct {
	Account       auth.Account
	Model         *mapping.ModelStruct
	UsernameField *mapping.StructField
	PasswordField *mapping.StructField
}

type LoginAccountRefresher interface {
	HandleLoginAccountRefresh(ctx context.Context, db database.DB, options *LoginOptions) error
}

type LoginInput struct {
	Username      string `json:"username"`
	Password      string `json:"password"`
	RememberToken bool   `json:"remember_token"`
}

type LoginOptions struct {
	Header        http.Header
	Account       auth.Account
	Password      *auth.Password
	RememberToken bool
}

type LoginOutput struct {
	Meta         codec.Meta `json:"meta,omitempty"`
	AccessToken  string     `json:"access_token"`
	RefreshToken string     `json:"refresh_token,omitempty"`
	TokenType    string     `json:"token_type,omitempty"`
	ExpiresIn    int64      `json:"expires_in,omitempty"`
}

type Option func(o *Options)

type Options struct {
	AccountModel             auth.Account
	AccountHandler           interface{}
	PathPrefix               string
	Middlewares              []server.Middleware
	RegisterMiddlewares      []server.Middleware
	LoginMiddlewares         []server.Middleware
	LogoutMiddlewares        []server.Middleware
	RefreshTokenMiddlewares  []server.Middleware
	StrictUnmarshal          bool
	PasswordValidator        auth.PasswordValidator
	PasswordScorer           auth.PasswordScorer
	UsernameValidator        auth.UsernameValidator
	TokenExpiration          time.Duration
	RememberTokenExpiration  time.Duration
	RefreshTokenExpiration   time.Duration
	PermitRefreshTokenLogout bool
}

type RegisterAccountMarshaler interface {
	MarshalRegisteredAccount(ctx context.Context, options *RegisterAccountOptions) (*codec.Payload, error)
}

type RegisterAccountOptions struct {
	Account    auth.Account
	Password   *auth.Password
	Meta       codec.Meta
	Attributes map[string]interface{}
}

type WithContextLoginer interface {
	LoginWithContext(ctx context.Context) (context.Context, error)
}

type WithTransactionLoginer interface {
	LoginWithTransaction() *query.TxOptions
}