andwati/zitadel
1
0
Fork 0
mirror of https://github.com/andwati/zitadel.git synced 2026-11-13 17:35:12 +00:00
Code Issues Packages Projects Releases Wiki Activity

feat(repository): implement user repository (#10967)

Browse Source 
## Summary

This PR introduces the relational user repository for backend v3,
including schema, repository APIs, reducers/projections, and tests for
both human and machine users.

## What changed

* Added user-focused relational migrations (users, verifications,
metadata, PATs, machine keys, passkeys, identity provider links) and
related FK wiring.
* Implemented/expanded repository domain contracts and storage
implementations for human and machine user flows.
* Added support for machine secret handling and aligned access token
type modeling.
* Extended user domain models (verifications, password/email/phone/TOTP
state, passkeys, metadata, invite handling, identity provider links).
* Updated projection/reduction coverage and integration tests for key
user lifecycle events.
* Regenerated and updated mocks/enums plus supporting database
change/column utilities.

## Notes for reviewers

* This PR is large because it establishes the foundational relational
user storage layer and related test scaffolding. Sorry for that.

## Closes

Closes #10218
Closes #10224
Closes #10225
Closes #10209
Closes #10802

---------

Co-authored-by: Iraq Jaber <[email protected]>
Co-authored-by: Copilot <[email protected]>
Co-authored-by: Marco A. <[email protected]>
Co-authored-by: Tim Möhlmann <[email protected]>
This commit is contained in:
Silvan
2026-02-23 16:03:47 +01:00
committed by GitHub
co-authored by Iraq Jaber Copilot Marco A. Tim Möhlmann
parent 40c7b38ca1
commit 5df8a97f9d
73 changed files with 15914 additions and 1661 deletions
Download Patch File Download Diff File Expand all files Collapse all files
backend/v3/domain/accesstokentype_enumer.go
+82
View File
@@ -0,0 +1,82 @@
// Code generated by "enumer -type AccessTokenType -transform lower -trimprefix AccessTokenType"; DO NOT EDIT.
package domain
import (
"fmt"
"strings"
)
const _AccessTokenTypeName = "unspecifiedbearerjwt"
var _AccessTokenTypeIndex = [...]uint8{0, 11, 17, 20}
const _AccessTokenTypeLowerName = "unspecifiedbearerjwt"
func (i AccessTokenType) String() string {
if i >= AccessTokenType(len(_AccessTokenTypeIndex)-1) {
return fmt.Sprintf("AccessTokenType(%d)", i)
}
return _AccessTokenTypeName[_AccessTokenTypeIndex[i]:_AccessTokenTypeIndex[i+1]]
}
// An "invalid array index" compiler error signifies that the constant values have changed.
// Re-run the stringer command to generate them again.
func _AccessTokenTypeNoOp() {
var x [1]struct{}
_ = x[AccessTokenTypeUnspecified-(0)]
_ = x[AccessTokenTypeBearer-(1)]
_ = x[AccessTokenTypeJWT-(2)]
}
var _AccessTokenTypeValues = []AccessTokenType{AccessTokenTypeUnspecified, AccessTokenTypeBearer, AccessTokenTypeJWT}
var _AccessTokenTypeNameToValueMap = map[string]AccessTokenType{
_AccessTokenTypeName[0:11]: AccessTokenTypeUnspecified,
_AccessTokenTypeLowerName[0:11]: AccessTokenTypeUnspecified,
_AccessTokenTypeName[11:17]: AccessTokenTypeBearer,
_AccessTokenTypeLowerName[11:17]: AccessTokenTypeBearer,
_AccessTokenTypeName[17:20]: AccessTokenTypeJWT,
_AccessTokenTypeLowerName[17:20]: AccessTokenTypeJWT,
}
var _AccessTokenTypeNames = []string{
_AccessTokenTypeName[0:11],
_AccessTokenTypeName[11:17],
_AccessTokenTypeName[17:20],
}
// AccessTokenTypeString retrieves an enum value from the enum constants string name.
// Throws an error if the param is not part of the enum.
func AccessTokenTypeString(s string) (AccessTokenType, error) {
if val, ok := _AccessTokenTypeNameToValueMap[s]; ok {
return val, nil
}
if val, ok := _AccessTokenTypeNameToValueMap[strings.ToLower(s)]; ok {
return val, nil
}
return 0, fmt.Errorf("%s does not belong to AccessTokenType values", s)
}
// AccessTokenTypeValues returns all values of the enum
func AccessTokenTypeValues() []AccessTokenType {
return _AccessTokenTypeValues
}
// AccessTokenTypeStrings returns a slice of all String values of the enum
func AccessTokenTypeStrings() []string {
strs := make([]string, len(_AccessTokenTypeNames))
copy(strs, _AccessTokenTypeNames)
return strs
}
// IsAAccessTokenType returns "true" if the value is listed in the enum definition. "false" otherwise
func (i AccessTokenType) IsAAccessTokenType() bool {
for _, v := range _AccessTokenTypeValues {
if i == v {
return true
}
}
return false
}
backend/v3/domain/check.go
-71
View File
@@ -1,71 +0,0 @@
package domain
import (
"time"
"github.com/zitadel/zitadel/internal/crypto"
)
type Check struct {
Code *crypto.CryptoValue `db:"code"`
ExpiresAt *time.Time `db:"expires_at"`
FailedAttempts uint8 `db:"failed_attempts"`
}
type CheckType interface {
isCheckType()
}
type PasswordCheckType interface {
isPasswordCheckType()
}
// CheckTypeInit initializes a new check.
type CheckTypeInit struct {
// CreatedAt is the time when the check was created.
// If zero, the current time will be used.
CreatedAt time.Time
// Expiry is the duration after which the check expires.
Expiry *time.Duration
// Code to be used for the check.
Code *crypto.CryptoValue
}
// isCheckType implements [CheckType].
func (v *CheckTypeInit) isCheckType() {}
var _ CheckType = (*CheckTypeInit)(nil)
// CheckTypeFailed indicates that the check failed.
// It is used to increment the failed attempts counter.
type CheckTypeFailed struct {
FailedAt time.Time
}
// isCheckType implements [CheckType].
func (v *CheckTypeFailed) isCheckType() {}
// isPasswordCheckType implements [PasswordCheckType].
func (v *CheckTypeFailed) isPasswordCheckType() {}
var (
_ CheckType = (*CheckTypeFailed)(nil)
_ PasswordCheckType = (*CheckTypeFailed)(nil)
)
// CheckTypeSucceeded indicates that the check succeeded.
// It is used to reset the failed attempts counter.
type CheckTypeSucceeded struct {
SucceededAt time.Time
}
// isCheckType implements [CheckType].
func (v *CheckTypeSucceeded) isCheckType() {}
// isPasswordCheckType implements [PasswordCheckType].
func (v *CheckTypeSucceeded) isPasswordCheckType() {}
var (
_ CheckType = (*CheckTypeSucceeded)(nil)
_ PasswordCheckType = (*CheckTypeSucceeded)(nil)
)
backend/v3/domain/machinekeytype_enumer.go
+11 -15
View File
@@ -7,11 +7,11 @@ import (
"strings"
)
const _MachineKeyTypeName = "unspecifiedjsonnone"
const _MachineKeyTypeName = "nonejson"
var _MachineKeyTypeIndex = [...]uint8{0, 11, 15, 19}
var _MachineKeyTypeIndex = [...]uint8{0, 4, 8}
const _MachineKeyTypeLowerName = "unspecifiedjsonnone"
const _MachineKeyTypeLowerName = "nonejson"
func (i MachineKeyType) String() string {
if i >= MachineKeyType(len(_MachineKeyTypeIndex)-1) {
@@ -24,26 +24,22 @@ func (i MachineKeyType) String() string {
// Re-run the stringer command to generate them again.
func _MachineKeyTypeNoOp() {
var x [1]struct{}
_ = x[MachineKeyTypeUnspecified-(0)]
_ = x[MachineKeyTypeNone-(0)]
_ = x[MachineKeyTypeJSON-(1)]
_ = x[MachineKeyTypeNone-(2)]
}
var _MachineKeyTypeValues = []MachineKeyType{MachineKeyTypeUnspecified, MachineKeyTypeJSON, MachineKeyTypeNone}
var _MachineKeyTypeValues = []MachineKeyType{MachineKeyTypeNone, MachineKeyTypeJSON}
var _MachineKeyTypeNameToValueMap = map[string]MachineKeyType{
_MachineKeyTypeName[0:11]: MachineKeyTypeUnspecified,
_MachineKeyTypeLowerName[0:11]: MachineKeyTypeUnspecified,
_MachineKeyTypeName[11:15]: MachineKeyTypeJSON,
_MachineKeyTypeLowerName[11:15]: MachineKeyTypeJSON,
_MachineKeyTypeName[15:19]: MachineKeyTypeNone,
_MachineKeyTypeLowerName[15:19]: MachineKeyTypeNone,
_MachineKeyTypeName[0:4]: MachineKeyTypeNone,
_MachineKeyTypeLowerName[0:4]: MachineKeyTypeNone,
_MachineKeyTypeName[4:8]: MachineKeyTypeJSON,
_MachineKeyTypeLowerName[4:8]: MachineKeyTypeJSON,
}
var _MachineKeyTypeNames = []string{
_MachineKeyTypeName[0:11],
_MachineKeyTypeName[11:15],
_MachineKeyTypeName[15:19],
_MachineKeyTypeName[0:4],
_MachineKeyTypeName[4:8],
}
// MachineKeyTypeString retrieves an enum value from the enum constants string name.
backend/v3/domain/mock/authorization.mock.go
+38
View File
@@ -158,6 +158,44 @@ func (c *MockAuthorizationRepositoryDeleteCall) DoAndReturn(f func(context.Conte
return c
}
// ExistsRole mocks base method.
func (m *MockAuthorizationRepository) ExistsRole(cond database.Condition) database.Condition {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "ExistsRole", cond)
ret0, _ := ret[0].(database.Condition)
return ret0
}
// ExistsRole indicates an expected call of ExistsRole.
func (mr *MockAuthorizationRepositoryMockRecorder) ExistsRole(cond any) *MockAuthorizationRepositoryExistsRoleCall {
mr.mock.ctrl.T.Helper()
call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ExistsRole", reflect.TypeOf((*MockAuthorizationRepository)(nil).ExistsRole), cond)
return &MockAuthorizationRepositoryExistsRoleCall{Call: call}
}
// MockAuthorizationRepositoryExistsRoleCall wrap *gomock.Call
type MockAuthorizationRepositoryExistsRoleCall struct {
*gomock.Call
}
// Return rewrite *gomock.Call.Return
func (c *MockAuthorizationRepositoryExistsRoleCall) Return(arg0 database.Condition) *MockAuthorizationRepositoryExistsRoleCall {
c.Call = c.Call.Return(arg0)
return c
}
// Do rewrite *gomock.Call.Do
func (c *MockAuthorizationRepositoryExistsRoleCall) Do(f func(database.Condition) database.Condition) *MockAuthorizationRepositoryExistsRoleCall {
c.Call = c.Call.Do(f)
return c
}
// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockAuthorizationRepositoryExistsRoleCall) DoAndReturn(f func(database.Condition) database.Condition) *MockAuthorizationRepositoryExistsRoleCall {
c.Call = c.Call.DoAndReturn(f)
return c
}
// Get mocks base method.
func (m *MockAuthorizationRepository) Get(ctx context.Context, client database.QueryExecutor, opts ...database.QueryOption) (*domain.Authorization, error) {
m.ctrl.T.Helper()
backend/v3/domain/mock/human_user.mock.go
+1106 -421
View File
File diff suppressed because it is too large Load Diff
backend/v3/domain/mock/instance_domain.mock.go
+4 -4
View File
@@ -354,17 +354,17 @@ func (c *MockInstanceDomainRepositoryIsGeneratedColumnCall) DoAndReturn(f func()
}
// IsGeneratedCondition mocks base method.
func (m *MockInstanceDomainRepository) IsGeneratedCondition(arg0 bool) database.Condition {
func (m *MockInstanceDomainRepository) IsGeneratedCondition(isGenerated bool) database.Condition {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "IsGeneratedCondition", arg0)
ret := m.ctrl.Call(m, "IsGeneratedCondition", isGenerated)
ret0, _ := ret[0].(database.Condition)
return ret0
}
// IsGeneratedCondition indicates an expected call of IsGeneratedCondition.
func (mr *MockInstanceDomainRepositoryMockRecorder) IsGeneratedCondition(arg0 any) *MockInstanceDomainRepositoryIsGeneratedConditionCall {
func (mr *MockInstanceDomainRepositoryMockRecorder) IsGeneratedCondition(isGenerated any) *MockInstanceDomainRepositoryIsGeneratedConditionCall {
mr.mock.ctrl.T.Helper()
call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IsGeneratedCondition", reflect.TypeOf((*MockInstanceDomainRepository)(nil).IsGeneratedCondition), arg0)
call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IsGeneratedCondition", reflect.TypeOf((*MockInstanceDomainRepository)(nil).IsGeneratedCondition), isGenerated)
return &MockInstanceDomainRepositoryIsGeneratedConditionCall{Call: call}
}
backend/v3/domain/mock/machine_user.mock.go
+142 -66
View File
@@ -237,6 +237,44 @@ func (c *MockMachineUserRepositoryExistsMetadataCall) DoAndReturn(f func(databas
return c
}
// IDColumn mocks base method.
func (m *MockMachineUserRepository) IDColumn() database.Column {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "IDColumn")
ret0, _ := ret[0].(database.Column)
return ret0
}
// IDColumn indicates an expected call of IDColumn.
func (mr *MockMachineUserRepositoryMockRecorder) IDColumn() *MockMachineUserRepositoryIDColumnCall {
mr.mock.ctrl.T.Helper()
call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IDColumn", reflect.TypeOf((*MockMachineUserRepository)(nil).IDColumn))
return &MockMachineUserRepositoryIDColumnCall{Call: call}
}
// MockMachineUserRepositoryIDColumnCall wrap *gomock.Call
type MockMachineUserRepositoryIDColumnCall struct {
*gomock.Call
}
// Return rewrite *gomock.Call.Return
func (c *MockMachineUserRepositoryIDColumnCall) Return(arg0 database.Column) *MockMachineUserRepositoryIDColumnCall {
c.Call = c.Call.Return(arg0)
return c
}
// Do rewrite *gomock.Call.Do
func (c *MockMachineUserRepositoryIDColumnCall) Do(f func() database.Column) *MockMachineUserRepositoryIDColumnCall {
c.Call = c.Call.Do(f)
return c
}
// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockMachineUserRepositoryIDColumnCall) DoAndReturn(f func() database.Column) *MockMachineUserRepositoryIDColumnCall {
c.Call = c.Call.DoAndReturn(f)
return c
}
// IDCondition mocks base method.
func (m *MockMachineUserRepository) IDCondition(userID string) database.Condition {
m.ctrl.T.Helper()
@@ -275,6 +313,44 @@ func (c *MockMachineUserRepositoryIDConditionCall) DoAndReturn(f func(string) da
return c
}
// InstanceIDColumn mocks base method.
func (m *MockMachineUserRepository) InstanceIDColumn() database.Column {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "InstanceIDColumn")
ret0, _ := ret[0].(database.Column)
return ret0
}
// InstanceIDColumn indicates an expected call of InstanceIDColumn.
func (mr *MockMachineUserRepositoryMockRecorder) InstanceIDColumn() *MockMachineUserRepositoryInstanceIDColumnCall {
mr.mock.ctrl.T.Helper()
call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InstanceIDColumn", reflect.TypeOf((*MockMachineUserRepository)(nil).InstanceIDColumn))
return &MockMachineUserRepositoryInstanceIDColumnCall{Call: call}
}
// MockMachineUserRepositoryInstanceIDColumnCall wrap *gomock.Call
type MockMachineUserRepositoryInstanceIDColumnCall struct {
*gomock.Call
}
// Return rewrite *gomock.Call.Return
func (c *MockMachineUserRepositoryInstanceIDColumnCall) Return(arg0 database.Column) *MockMachineUserRepositoryInstanceIDColumnCall {
c.Call = c.Call.Return(arg0)
return c
}
// Do rewrite *gomock.Call.Do
func (c *MockMachineUserRepositoryInstanceIDColumnCall) Do(f func() database.Column) *MockMachineUserRepositoryInstanceIDColumnCall {
c.Call = c.Call.Do(f)
return c
}
// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockMachineUserRepositoryInstanceIDColumnCall) DoAndReturn(f func() database.Column) *MockMachineUserRepositoryInstanceIDColumnCall {
c.Call = c.Call.DoAndReturn(f)
return c
}
// InstanceIDCondition mocks base method.
func (m *MockMachineUserRepository) InstanceIDCondition(instanceID string) database.Condition {
m.ctrl.T.Helper()
@@ -351,116 +427,78 @@ func (c *MockMachineUserRepositoryLoginNameConditionCall) DoAndReturn(f func(dat
return c
}
// MetadataKeyCondition mocks base method.
func (m *MockMachineUserRepository) MetadataKeyCondition(key string) database.Condition {
// MetadataConditions mocks base method.
func (m *MockMachineUserRepository) MetadataConditions() domain.UserMetadataConditions {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "MetadataKeyCondition", key)
ret0, _ := ret[0].(database.Condition)
ret := m.ctrl.Call(m, "MetadataConditions")
ret0, _ := ret[0].(domain.UserMetadataConditions)
return ret0
}
// MetadataKeyCondition indicates an expected call of MetadataKeyCondition.
func (mr *MockMachineUserRepositoryMockRecorder) MetadataKeyCondition(key any) *MockMachineUserRepositoryMetadataKeyConditionCall {
// MetadataConditions indicates an expected call of MetadataConditions.
func (mr *MockMachineUserRepositoryMockRecorder) MetadataConditions() *MockMachineUserRepositoryMetadataConditionsCall {
mr.mock.ctrl.T.Helper()
call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "MetadataKeyCondition", reflect.TypeOf((*MockMachineUserRepository)(nil).MetadataKeyCondition), key)
return &MockMachineUserRepositoryMetadataKeyConditionCall{Call: call}
call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "MetadataConditions", reflect.TypeOf((*MockMachineUserRepository)(nil).MetadataConditions))
return &MockMachineUserRepositoryMetadataConditionsCall{Call: call}
}
// MockMachineUserRepositoryMetadataKeyConditionCall wrap *gomock.Call
type MockMachineUserRepositoryMetadataKeyConditionCall struct {
// MockMachineUserRepositoryMetadataConditionsCall wrap *gomock.Call
type MockMachineUserRepositoryMetadataConditionsCall struct {
*gomock.Call
}
// Return rewrite *gomock.Call.Return
func (c *MockMachineUserRepositoryMetadataKeyConditionCall) Return(arg0 database.Condition) *MockMachineUserRepositoryMetadataKeyConditionCall {
func (c *MockMachineUserRepositoryMetadataConditionsCall) Return(arg0 domain.UserMetadataConditions) *MockMachineUserRepositoryMetadataConditionsCall {
c.Call = c.Call.Return(arg0)
return c
}
// Do rewrite *gomock.Call.Do
func (c *MockMachineUserRepositoryMetadataKeyConditionCall) Do(f func(string) database.Condition) *MockMachineUserRepositoryMetadataKeyConditionCall {
func (c *MockMachineUserRepositoryMetadataConditionsCall) Do(f func() domain.UserMetadataConditions) *MockMachineUserRepositoryMetadataConditionsCall {
c.Call = c.Call.Do(f)
return c
}
// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockMachineUserRepositoryMetadataKeyConditionCall) DoAndReturn(f func(string) database.Condition) *MockMachineUserRepositoryMetadataKeyConditionCall {
func (c *MockMachineUserRepositoryMetadataConditionsCall) DoAndReturn(f func() domain.UserMetadataConditions) *MockMachineUserRepositoryMetadataConditionsCall {
c.Call = c.Call.DoAndReturn(f)
return c
}
// MetadataValueCondition mocks base method.
func (m *MockMachineUserRepository) MetadataValueCondition(op database.BytesOperation, value []byte) database.Condition {
// OrganizationIDCondition mocks base method.
func (m *MockMachineUserRepository) OrganizationIDCondition(orgID string) database.Condition {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "MetadataValueCondition", op, value)
ret := m.ctrl.Call(m, "OrganizationIDCondition", orgID)
ret0, _ := ret[0].(database.Condition)
return ret0
}
// MetadataValueCondition indicates an expected call of MetadataValueCondition.
func (mr *MockMachineUserRepositoryMockRecorder) MetadataValueCondition(op, value any) *MockMachineUserRepositoryMetadataValueConditionCall {
// OrganizationIDCondition indicates an expected call of OrganizationIDCondition.
func (mr *MockMachineUserRepositoryMockRecorder) OrganizationIDCondition(orgID any) *MockMachineUserRepositoryOrganizationIDConditionCall {
mr.mock.ctrl.T.Helper()
call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "MetadataValueCondition", reflect.TypeOf((*MockMachineUserRepository)(nil).MetadataValueCondition), op, value)
return &MockMachineUserRepositoryMetadataValueConditionCall{Call: call}
call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "OrganizationIDCondition", reflect.TypeOf((*MockMachineUserRepository)(nil).OrganizationIDCondition), orgID)
return &MockMachineUserRepositoryOrganizationIDConditionCall{Call: call}
}
// MockMachineUserRepositoryMetadataValueConditionCall wrap *gomock.Call
type MockMachineUserRepositoryMetadataValueConditionCall struct {
// MockMachineUserRepositoryOrganizationIDConditionCall wrap *gomock.Call
type MockMachineUserRepositoryOrganizationIDConditionCall struct {
*gomock.Call
}
// Return rewrite *gomock.Call.Return
func (c *MockMachineUserRepositoryMetadataValueConditionCall) Return(arg0 database.Condition) *MockMachineUserRepositoryMetadataValueConditionCall {
func (c *MockMachineUserRepositoryOrganizationIDConditionCall) Return(arg0 database.Condition) *MockMachineUserRepositoryOrganizationIDConditionCall {
c.Call = c.Call.Return(arg0)
return c
}
// Do rewrite *gomock.Call.Do
func (c *MockMachineUserRepositoryMetadataValueConditionCall) Do(f func(database.BytesOperation, []byte) database.Condition) *MockMachineUserRepositoryMetadataValueConditionCall {
func (c *MockMachineUserRepositoryOrganizationIDConditionCall) Do(f func(string) database.Condition) *MockMachineUserRepositoryOrganizationIDConditionCall {
c.Call = c.Call.Do(f)
return c
}
// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockMachineUserRepositoryMetadataValueConditionCall) DoAndReturn(f func(database.BytesOperation, []byte) database.Condition) *MockMachineUserRepositoryMetadataValueConditionCall {
c.Call = c.Call.DoAndReturn(f)
return c
}
// OrgIDCondition mocks base method.
func (m *MockMachineUserRepository) OrgIDCondition(orgID string) database.Condition {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "OrgIDCondition", orgID)
ret0, _ := ret[0].(database.Condition)
return ret0
}
// OrgIDCondition indicates an expected call of OrgIDCondition.
func (mr *MockMachineUserRepositoryMockRecorder) OrgIDCondition(orgID any) *MockMachineUserRepositoryOrgIDConditionCall {
mr.mock.ctrl.T.Helper()
call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "OrgIDCondition", reflect.TypeOf((*MockMachineUserRepository)(nil).OrgIDCondition), orgID)
return &MockMachineUserRepositoryOrgIDConditionCall{Call: call}
}
// MockMachineUserRepositoryOrgIDConditionCall wrap *gomock.Call
type MockMachineUserRepositoryOrgIDConditionCall struct {
*gomock.Call
}
// Return rewrite *gomock.Call.Return
func (c *MockMachineUserRepositoryOrgIDConditionCall) Return(arg0 database.Condition) *MockMachineUserRepositoryOrgIDConditionCall {
c.Call = c.Call.Return(arg0)
return c
}
// Do rewrite *gomock.Call.Do
func (c *MockMachineUserRepositoryOrgIDConditionCall) Do(f func(string) database.Condition) *MockMachineUserRepositoryOrgIDConditionCall {
c.Call = c.Call.Do(f)
return c
}
// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockMachineUserRepositoryOrgIDConditionCall) DoAndReturn(f func(string) database.Condition) *MockMachineUserRepositoryOrgIDConditionCall {
func (c *MockMachineUserRepositoryOrganizationIDConditionCall) DoAndReturn(f func(string) database.Condition) *MockMachineUserRepositoryOrganizationIDConditionCall {
c.Call = c.Call.DoAndReturn(f)
return c
}
@@ -656,7 +694,7 @@ func (c *MockMachineUserRepositoryRemovePersonalAccessTokenCall) DoAndReturn(f f
}
// SetAccessTokenType mocks base method.
func (m *MockMachineUserRepository) SetAccessTokenType(tokenType domain.PersonalAccessTokenType) database.Change {
func (m *MockMachineUserRepository) SetAccessTokenType(tokenType domain.AccessTokenType) database.Change {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "SetAccessTokenType", tokenType)
ret0, _ := ret[0].(database.Change)
@@ -682,13 +720,13 @@ func (c *MockMachineUserRepositorySetAccessTokenTypeCall) Return(arg0 database.C
}
// Do rewrite *gomock.Call.Do
func (c *MockMachineUserRepositorySetAccessTokenTypeCall) Do(f func(domain.PersonalAccessTokenType) database.Change) *MockMachineUserRepositorySetAccessTokenTypeCall {
func (c *MockMachineUserRepositorySetAccessTokenTypeCall) Do(f func(domain.AccessTokenType) database.Change) *MockMachineUserRepositorySetAccessTokenTypeCall {
c.Call = c.Call.Do(f)
return c
}
// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockMachineUserRepositorySetAccessTokenTypeCall) DoAndReturn(f func(domain.PersonalAccessTokenType) database.Change) *MockMachineUserRepositorySetAccessTokenTypeCall {
func (c *MockMachineUserRepositorySetAccessTokenTypeCall) DoAndReturn(f func(domain.AccessTokenType) database.Change) *MockMachineUserRepositorySetAccessTokenTypeCall {
c.Call = c.Call.DoAndReturn(f)
return c
}
@@ -997,6 +1035,44 @@ func (c *MockMachineUserRepositoryStateConditionCall) DoAndReturn(f func(domain.
return c
}
// TypeColumn mocks base method.
func (m *MockMachineUserRepository) TypeColumn() database.Column {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "TypeColumn")
ret0, _ := ret[0].(database.Column)
return ret0
}
// TypeColumn indicates an expected call of TypeColumn.
func (mr *MockMachineUserRepositoryMockRecorder) TypeColumn() *MockMachineUserRepositoryTypeColumnCall {
mr.mock.ctrl.T.Helper()
call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TypeColumn", reflect.TypeOf((*MockMachineUserRepository)(nil).TypeColumn))
return &MockMachineUserRepositoryTypeColumnCall{Call: call}
}
// MockMachineUserRepositoryTypeColumnCall wrap *gomock.Call
type MockMachineUserRepositoryTypeColumnCall struct {
*gomock.Call
}
// Return rewrite *gomock.Call.Return
func (c *MockMachineUserRepositoryTypeColumnCall) Return(arg0 database.Column) *MockMachineUserRepositoryTypeColumnCall {
c.Call = c.Call.Return(arg0)
return c
}
// Do rewrite *gomock.Call.Do
func (c *MockMachineUserRepositoryTypeColumnCall) Do(f func() database.Column) *MockMachineUserRepositoryTypeColumnCall {
c.Call = c.Call.Do(f)
return c
}
// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockMachineUserRepositoryTypeColumnCall) DoAndReturn(f func() database.Column) *MockMachineUserRepositoryTypeColumnCall {
c.Call = c.Call.DoAndReturn(f)
return c
}
// TypeCondition mocks base method.
func (m *MockMachineUserRepository) TypeCondition(userType domain.UserType) database.Condition {
m.ctrl.T.Helper()
backend/v3/domain/mock/project.mock.go
+76
View File
@@ -202,6 +202,82 @@ func (c *MockProjectRepositoryGetCall) DoAndReturn(f func(context.Context, datab
return c
}
// GrantedOrganizationIDColumn mocks base method.
func (m *MockProjectRepository) GrantedOrganizationIDColumn() database.Column {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "GrantedOrganizationIDColumn")
ret0, _ := ret[0].(database.Column)
return ret0
}
// GrantedOrganizationIDColumn indicates an expected call of GrantedOrganizationIDColumn.
func (mr *MockProjectRepositoryMockRecorder) GrantedOrganizationIDColumn() *MockProjectRepositoryGrantedOrganizationIDColumnCall {
mr.mock.ctrl.T.Helper()
call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GrantedOrganizationIDColumn", reflect.TypeOf((*MockProjectRepository)(nil).GrantedOrganizationIDColumn))
return &MockProjectRepositoryGrantedOrganizationIDColumnCall{Call: call}
}
// MockProjectRepositoryGrantedOrganizationIDColumnCall wrap *gomock.Call
type MockProjectRepositoryGrantedOrganizationIDColumnCall struct {
*gomock.Call
}
// Return rewrite *gomock.Call.Return
func (c *MockProjectRepositoryGrantedOrganizationIDColumnCall) Return(arg0 database.Column) *MockProjectRepositoryGrantedOrganizationIDColumnCall {
c.Call = c.Call.Return(arg0)
return c
}
// Do rewrite *gomock.Call.Do
func (c *MockProjectRepositoryGrantedOrganizationIDColumnCall) Do(f func() database.Column) *MockProjectRepositoryGrantedOrganizationIDColumnCall {
c.Call = c.Call.Do(f)
return c
}
// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockProjectRepositoryGrantedOrganizationIDColumnCall) DoAndReturn(f func() database.Column) *MockProjectRepositoryGrantedOrganizationIDColumnCall {
c.Call = c.Call.DoAndReturn(f)
return c
}
// GrantedOrganizationIDCondition mocks base method.
func (m *MockProjectRepository) GrantedOrganizationIDCondition(organizationID string) database.Condition {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "GrantedOrganizationIDCondition", organizationID)
ret0, _ := ret[0].(database.Condition)
return ret0
}
// GrantedOrganizationIDCondition indicates an expected call of GrantedOrganizationIDCondition.
func (mr *MockProjectRepositoryMockRecorder) GrantedOrganizationIDCondition(organizationID any) *MockProjectRepositoryGrantedOrganizationIDConditionCall {
mr.mock.ctrl.T.Helper()
call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GrantedOrganizationIDCondition", reflect.TypeOf((*MockProjectRepository)(nil).GrantedOrganizationIDCondition), organizationID)
return &MockProjectRepositoryGrantedOrganizationIDConditionCall{Call: call}
}
// MockProjectRepositoryGrantedOrganizationIDConditionCall wrap *gomock.Call
type MockProjectRepositoryGrantedOrganizationIDConditionCall struct {
*gomock.Call
}
// Return rewrite *gomock.Call.Return
func (c *MockProjectRepositoryGrantedOrganizationIDConditionCall) Return(arg0 database.Condition) *MockProjectRepositoryGrantedOrganizationIDConditionCall {
c.Call = c.Call.Return(arg0)
return c
}
// Do rewrite *gomock.Call.Do
func (c *MockProjectRepositoryGrantedOrganizationIDConditionCall) Do(f func(string) database.Condition) *MockProjectRepositoryGrantedOrganizationIDConditionCall {
c.Call = c.Call.Do(f)
return c
}
// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockProjectRepositoryGrantedOrganizationIDConditionCall) DoAndReturn(f func(string) database.Condition) *MockProjectRepositoryGrantedOrganizationIDConditionCall {
c.Call = c.Call.DoAndReturn(f)
return c
}
// IDColumn mocks base method.
func (m *MockProjectRepository) IDColumn() database.Column {
m.ctrl.T.Helper()
backend/v3/domain/mock/project_grant.mock.go
+1013
View File
File diff suppressed because it is too large Load Diff
backend/v3/domain/mock/session.mock.go
+108 -107
View File
@@ -23,6 +23,7 @@ import (
type MockSessionRepository struct {
ctrl *gomock.Controller
recorder *MockSessionRepositoryMockRecorder
isgomock struct{}
}
// MockSessionRepositoryMockRecorder is the mock recorder for MockSessionRepository.
@@ -43,17 +44,17 @@ func (m *MockSessionRepository) EXPECT() *MockSessionRepositoryMockRecorder {
}
// ClearFactor mocks base method.
func (m *MockSessionRepository) ClearFactor(arg0 domain.SessionFactorType) database.Change {
func (m *MockSessionRepository) ClearFactor(factor domain.SessionFactorType) database.Change {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "ClearFactor", arg0)
ret := m.ctrl.Call(m, "ClearFactor", factor)
ret0, _ := ret[0].(database.Change)
return ret0
}
// ClearFactor indicates an expected call of ClearFactor.
func (mr *MockSessionRepositoryMockRecorder) ClearFactor(arg0 any) *MockSessionRepositoryClearFactorCall {
func (mr *MockSessionRepositoryMockRecorder) ClearFactor(factor any) *MockSessionRepositoryClearFactorCall {
mr.mock.ctrl.T.Helper()
call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClearFactor", reflect.TypeOf((*MockSessionRepository)(nil).ClearFactor), arg0)
call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClearFactor", reflect.TypeOf((*MockSessionRepository)(nil).ClearFactor), factor)
return &MockSessionRepositoryClearFactorCall{Call: call}
}
@@ -81,17 +82,17 @@ func (c *MockSessionRepositoryClearFactorCall) DoAndReturn(f func(domain.Session
}
// Create mocks base method.
func (m *MockSessionRepository) Create(arg0 context.Context, arg1 database.QueryExecutor, arg2 *domain.Session) error {
func (m *MockSessionRepository) Create(ctx context.Context, client database.QueryExecutor, user *domain.Session) error {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "Create", arg0, arg1, arg2)
ret := m.ctrl.Call(m, "Create", ctx, client, user)
ret0, _ := ret[0].(error)
return ret0
}
// Create indicates an expected call of Create.
func (mr *MockSessionRepositoryMockRecorder) Create(arg0, arg1, arg2 any) *MockSessionRepositoryCreateCall {
func (mr *MockSessionRepositoryMockRecorder) Create(ctx, client, user any) *MockSessionRepositoryCreateCall {
mr.mock.ctrl.T.Helper()
call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Create", reflect.TypeOf((*MockSessionRepository)(nil).Create), arg0, arg1, arg2)
call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Create", reflect.TypeOf((*MockSessionRepository)(nil).Create), ctx, client, user)
return &MockSessionRepositoryCreateCall{Call: call}
}
@@ -157,17 +158,17 @@ func (c *MockSessionRepositoryCreatedAtColumnCall) DoAndReturn(f func() database
}
// CreatedAtCondition mocks base method.
func (m *MockSessionRepository) CreatedAtCondition(arg0 database.NumberOperation, arg1 time.Time) database.Condition {
func (m *MockSessionRepository) CreatedAtCondition(op database.NumberOperation, createdAt time.Time) database.Condition {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "CreatedAtCondition", arg0, arg1)
ret := m.ctrl.Call(m, "CreatedAtCondition", op, createdAt)
ret0, _ := ret[0].(database.Condition)
return ret0
}
// CreatedAtCondition indicates an expected call of CreatedAtCondition.
func (mr *MockSessionRepositoryMockRecorder) CreatedAtCondition(arg0, arg1 any) *MockSessionRepositoryCreatedAtConditionCall {
func (mr *MockSessionRepositoryMockRecorder) CreatedAtCondition(op, createdAt any) *MockSessionRepositoryCreatedAtConditionCall {
mr.mock.ctrl.T.Helper()
call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreatedAtCondition", reflect.TypeOf((*MockSessionRepository)(nil).CreatedAtCondition), arg0, arg1)
call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreatedAtCondition", reflect.TypeOf((*MockSessionRepository)(nil).CreatedAtCondition), op, createdAt)
return &MockSessionRepositoryCreatedAtConditionCall{Call: call}
}
@@ -195,17 +196,17 @@ func (c *MockSessionRepositoryCreatedAtConditionCall) DoAndReturn(f func(databas
}
// CreatorIDCondition mocks base method.
func (m *MockSessionRepository) CreatorIDCondition(arg0 string) database.Condition {
func (m *MockSessionRepository) CreatorIDCondition(creatorID string) database.Condition {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "CreatorIDCondition", arg0)
ret := m.ctrl.Call(m, "CreatorIDCondition", creatorID)
ret0, _ := ret[0].(database.Condition)
return ret0
}
// CreatorIDCondition indicates an expected call of CreatorIDCondition.
func (mr *MockSessionRepositoryMockRecorder) CreatorIDCondition(arg0 any) *MockSessionRepositoryCreatorIDConditionCall {
func (mr *MockSessionRepositoryMockRecorder) CreatorIDCondition(creatorID any) *MockSessionRepositoryCreatorIDConditionCall {
mr.mock.ctrl.T.Helper()
call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreatorIDCondition", reflect.TypeOf((*MockSessionRepository)(nil).CreatorIDCondition), arg0)
call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreatorIDCondition", reflect.TypeOf((*MockSessionRepository)(nil).CreatorIDCondition), creatorID)
return &MockSessionRepositoryCreatorIDConditionCall{Call: call}
}
@@ -233,18 +234,18 @@ func (c *MockSessionRepositoryCreatorIDConditionCall) DoAndReturn(f func(string)
}
// Delete mocks base method.
func (m *MockSessionRepository) Delete(arg0 context.Context, arg1 database.QueryExecutor, arg2 database.Condition) (int64, error) {
func (m *MockSessionRepository) Delete(ctx context.Context, client database.QueryExecutor, condition database.Condition) (int64, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "Delete", arg0, arg1, arg2)
ret := m.ctrl.Call(m, "Delete", ctx, client, condition)
ret0, _ := ret[0].(int64)
ret1, _ := ret[1].(error)
return ret0, ret1
}
// Delete indicates an expected call of Delete.
func (mr *MockSessionRepositoryMockRecorder) Delete(arg0, arg1, arg2 any) *MockSessionRepositoryDeleteCall {
func (mr *MockSessionRepositoryMockRecorder) Delete(ctx, client, condition any) *MockSessionRepositoryDeleteCall {
mr.mock.ctrl.T.Helper()
call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Delete", reflect.TypeOf((*MockSessionRepository)(nil).Delete), arg0, arg1, arg2)
call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Delete", reflect.TypeOf((*MockSessionRepository)(nil).Delete), ctx, client, condition)
return &MockSessionRepositoryDeleteCall{Call: call}
}
@@ -272,17 +273,17 @@ func (c *MockSessionRepositoryDeleteCall) DoAndReturn(f func(context.Context, da
}
// ExistsFactor mocks base method.
func (m *MockSessionRepository) ExistsFactor(arg0 database.Condition) database.Condition {
func (m *MockSessionRepository) ExistsFactor(condition database.Condition) database.Condition {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "ExistsFactor", arg0)
ret := m.ctrl.Call(m, "ExistsFactor", condition)
ret0, _ := ret[0].(database.Condition)
return ret0
}
// ExistsFactor indicates an expected call of ExistsFactor.
func (mr *MockSessionRepositoryMockRecorder) ExistsFactor(arg0 any) *MockSessionRepositoryExistsFactorCall {
func (mr *MockSessionRepositoryMockRecorder) ExistsFactor(condition any) *MockSessionRepositoryExistsFactorCall {
mr.mock.ctrl.T.Helper()
call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ExistsFactor", reflect.TypeOf((*MockSessionRepository)(nil).ExistsFactor), arg0)
call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ExistsFactor", reflect.TypeOf((*MockSessionRepository)(nil).ExistsFactor), condition)
return &MockSessionRepositoryExistsFactorCall{Call: call}
}
@@ -310,17 +311,17 @@ func (c *MockSessionRepositoryExistsFactorCall) DoAndReturn(f func(database.Cond
}
// ExistsMetadata mocks base method.
func (m *MockSessionRepository) ExistsMetadata(arg0 database.Condition) database.Condition {
func (m *MockSessionRepository) ExistsMetadata(condition database.Condition) database.Condition {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "ExistsMetadata", arg0)
ret := m.ctrl.Call(m, "ExistsMetadata", condition)
ret0, _ := ret[0].(database.Condition)
return ret0
}
// ExistsMetadata indicates an expected call of ExistsMetadata.
func (mr *MockSessionRepositoryMockRecorder) ExistsMetadata(arg0 any) *MockSessionRepositoryExistsMetadataCall {
func (mr *MockSessionRepositoryMockRecorder) ExistsMetadata(condition any) *MockSessionRepositoryExistsMetadataCall {
mr.mock.ctrl.T.Helper()
call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ExistsMetadata", reflect.TypeOf((*MockSessionRepository)(nil).ExistsMetadata), arg0)
call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ExistsMetadata", reflect.TypeOf((*MockSessionRepository)(nil).ExistsMetadata), condition)
return &MockSessionRepositoryExistsMetadataCall{Call: call}
}
@@ -386,17 +387,17 @@ func (c *MockSessionRepositoryExpirationColumnCall) DoAndReturn(f func() databas
}
// ExpirationCondition mocks base method.
func (m *MockSessionRepository) ExpirationCondition(arg0 database.NumberOperation, arg1 time.Time) database.Condition {
func (m *MockSessionRepository) ExpirationCondition(op database.NumberOperation, expiration time.Time) database.Condition {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "ExpirationCondition", arg0, arg1)
ret := m.ctrl.Call(m, "ExpirationCondition", op, expiration)
ret0, _ := ret[0].(database.Condition)
return ret0
}
// ExpirationCondition indicates an expected call of ExpirationCondition.
func (mr *MockSessionRepositoryMockRecorder) ExpirationCondition(arg0, arg1 any) *MockSessionRepositoryExpirationConditionCall {
func (mr *MockSessionRepositoryMockRecorder) ExpirationCondition(op, expiration any) *MockSessionRepositoryExpirationConditionCall {
mr.mock.ctrl.T.Helper()
call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ExpirationCondition", reflect.TypeOf((*MockSessionRepository)(nil).ExpirationCondition), arg0, arg1)
call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ExpirationCondition", reflect.TypeOf((*MockSessionRepository)(nil).ExpirationCondition), op, expiration)
return &MockSessionRepositoryExpirationConditionCall{Call: call}
}
@@ -462,10 +463,10 @@ func (c *MockSessionRepositoryFactorConditionsCall) DoAndReturn(f func() domain.
}
// Get mocks base method.
func (m *MockSessionRepository) Get(arg0 context.Context, arg1 database.QueryExecutor, arg2 ...database.QueryOption) (*domain.Session, error) {
func (m *MockSessionRepository) Get(ctx context.Context, client database.QueryExecutor, opts ...database.QueryOption) (*domain.Session, error) {
m.ctrl.T.Helper()
varargs := []any{arg0, arg1}
for _, a := range arg2 {
varargs := []any{ctx, client}
for _, a := range opts {
varargs = append(varargs, a)
}
ret := m.ctrl.Call(m, "Get", varargs...)
@@ -475,9 +476,9 @@ func (m *MockSessionRepository) Get(arg0 context.Context, arg1 database.QueryExe
}
// Get indicates an expected call of Get.
func (mr *MockSessionRepositoryMockRecorder) Get(arg0, arg1 any, arg2 ...any) *MockSessionRepositoryGetCall {
func (mr *MockSessionRepositoryMockRecorder) Get(ctx, client any, opts ...any) *MockSessionRepositoryGetCall {
mr.mock.ctrl.T.Helper()
varargs := append([]any{arg0, arg1}, arg2...)
varargs := append([]any{ctx, client}, opts...)
call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Get", reflect.TypeOf((*MockSessionRepository)(nil).Get), varargs...)
return &MockSessionRepositoryGetCall{Call: call}
}
@@ -544,17 +545,17 @@ func (c *MockSessionRepositoryIDColumnCall) DoAndReturn(f func() database.Column
}
// IDCondition mocks base method.
func (m *MockSessionRepository) IDCondition(arg0 string) database.Condition {
func (m *MockSessionRepository) IDCondition(sessionID string) database.Condition {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "IDCondition", arg0)
ret := m.ctrl.Call(m, "IDCondition", sessionID)
ret0, _ := ret[0].(database.Condition)
return ret0
}
// IDCondition indicates an expected call of IDCondition.
func (mr *MockSessionRepositoryMockRecorder) IDCondition(arg0 any) *MockSessionRepositoryIDConditionCall {
func (mr *MockSessionRepositoryMockRecorder) IDCondition(sessionID any) *MockSessionRepositoryIDConditionCall {
mr.mock.ctrl.T.Helper()
call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IDCondition", reflect.TypeOf((*MockSessionRepository)(nil).IDCondition), arg0)
call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IDCondition", reflect.TypeOf((*MockSessionRepository)(nil).IDCondition), sessionID)
return &MockSessionRepositoryIDConditionCall{Call: call}
}
@@ -620,17 +621,17 @@ func (c *MockSessionRepositoryInstanceIDColumnCall) DoAndReturn(f func() databas
}
// InstanceIDCondition mocks base method.
func (m *MockSessionRepository) InstanceIDCondition(arg0 string) database.Condition {
func (m *MockSessionRepository) InstanceIDCondition(instanceID string) database.Condition {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "InstanceIDCondition", arg0)
ret := m.ctrl.Call(m, "InstanceIDCondition", instanceID)
ret0, _ := ret[0].(database.Condition)
return ret0
}
// InstanceIDCondition indicates an expected call of InstanceIDCondition.
func (mr *MockSessionRepositoryMockRecorder) InstanceIDCondition(arg0 any) *MockSessionRepositoryInstanceIDConditionCall {
func (mr *MockSessionRepositoryMockRecorder) InstanceIDCondition(instanceID any) *MockSessionRepositoryInstanceIDConditionCall {
mr.mock.ctrl.T.Helper()
call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InstanceIDCondition", reflect.TypeOf((*MockSessionRepository)(nil).InstanceIDCondition), arg0)
call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InstanceIDCondition", reflect.TypeOf((*MockSessionRepository)(nil).InstanceIDCondition), instanceID)
return &MockSessionRepositoryInstanceIDConditionCall{Call: call}
}
@@ -696,10 +697,10 @@ func (c *MockSessionRepositoryLifetimeColumnCall) DoAndReturn(f func() database.
}
// List mocks base method.
func (m *MockSessionRepository) List(arg0 context.Context, arg1 database.QueryExecutor, arg2 ...database.QueryOption) ([]*domain.Session, error) {
func (m *MockSessionRepository) List(ctx context.Context, client database.QueryExecutor, opts ...database.QueryOption) ([]*domain.Session, error) {
m.ctrl.T.Helper()
varargs := []any{arg0, arg1}
for _, a := range arg2 {
varargs := []any{ctx, client}
for _, a := range opts {
varargs = append(varargs, a)
}
ret := m.ctrl.Call(m, "List", varargs...)
@@ -709,9 +710,9 @@ func (m *MockSessionRepository) List(arg0 context.Context, arg1 database.QueryEx
}
// List indicates an expected call of List.
func (mr *MockSessionRepositoryMockRecorder) List(arg0, arg1 any, arg2 ...any) *MockSessionRepositoryListCall {
func (mr *MockSessionRepositoryMockRecorder) List(ctx, client any, opts ...any) *MockSessionRepositoryListCall {
mr.mock.ctrl.T.Helper()
varargs := append([]any{arg0, arg1}, arg2...)
varargs := append([]any{ctx, client}, opts...)
call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "List", reflect.TypeOf((*MockSessionRepository)(nil).List), varargs...)
return &MockSessionRepositoryListCall{Call: call}
}
@@ -816,17 +817,17 @@ func (c *MockSessionRepositoryPrimaryKeyColumnsCall) DoAndReturn(f func() []data
}
// PrimaryKeyCondition mocks base method.
func (m *MockSessionRepository) PrimaryKeyCondition(arg0, arg1 string) database.Condition {
func (m *MockSessionRepository) PrimaryKeyCondition(instanceID, sessionID string) database.Condition {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "PrimaryKeyCondition", arg0, arg1)
ret := m.ctrl.Call(m, "PrimaryKeyCondition", instanceID, sessionID)
ret0, _ := ret[0].(database.Condition)
return ret0
}
// PrimaryKeyCondition indicates an expected call of PrimaryKeyCondition.
func (mr *MockSessionRepositoryMockRecorder) PrimaryKeyCondition(arg0, arg1 any) *MockSessionRepositoryPrimaryKeyConditionCall {
func (mr *MockSessionRepositoryMockRecorder) PrimaryKeyCondition(instanceID, sessionID any) *MockSessionRepositoryPrimaryKeyConditionCall {
mr.mock.ctrl.T.Helper()
call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PrimaryKeyCondition", reflect.TypeOf((*MockSessionRepository)(nil).PrimaryKeyCondition), arg0, arg1)
call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PrimaryKeyCondition", reflect.TypeOf((*MockSessionRepository)(nil).PrimaryKeyCondition), instanceID, sessionID)
return &MockSessionRepositoryPrimaryKeyConditionCall{Call: call}
}
@@ -854,17 +855,17 @@ func (c *MockSessionRepositoryPrimaryKeyConditionCall) DoAndReturn(f func(string
}
// SetChallenge mocks base method.
func (m *MockSessionRepository) SetChallenge(arg0 domain.SessionChallenge) database.Change {
func (m *MockSessionRepository) SetChallenge(challenge domain.SessionChallenge) database.Change {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "SetChallenge", arg0)
ret := m.ctrl.Call(m, "SetChallenge", challenge)
ret0, _ := ret[0].(database.Change)
return ret0
}
// SetChallenge indicates an expected call of SetChallenge.
func (mr *MockSessionRepositoryMockRecorder) SetChallenge(arg0 any) *MockSessionRepositorySetChallengeCall {
func (mr *MockSessionRepositoryMockRecorder) SetChallenge(challenge any) *MockSessionRepositorySetChallengeCall {
mr.mock.ctrl.T.Helper()
call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetChallenge", reflect.TypeOf((*MockSessionRepository)(nil).SetChallenge), arg0)
call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetChallenge", reflect.TypeOf((*MockSessionRepository)(nil).SetChallenge), challenge)
return &MockSessionRepositorySetChallengeCall{Call: call}
}
@@ -892,17 +893,17 @@ func (c *MockSessionRepositorySetChallengeCall) DoAndReturn(f func(domain.Sessio
}
// SetFactor mocks base method.
func (m *MockSessionRepository) SetFactor(arg0 domain.SessionFactor) database.Change {
func (m *MockSessionRepository) SetFactor(factor domain.SessionFactor) database.Change {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "SetFactor", arg0)
ret := m.ctrl.Call(m, "SetFactor", factor)
ret0, _ := ret[0].(database.Change)
return ret0
}
// SetFactor indicates an expected call of SetFactor.
func (mr *MockSessionRepositoryMockRecorder) SetFactor(arg0 any) *MockSessionRepositorySetFactorCall {
func (mr *MockSessionRepositoryMockRecorder) SetFactor(factor any) *MockSessionRepositorySetFactorCall {
mr.mock.ctrl.T.Helper()
call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetFactor", reflect.TypeOf((*MockSessionRepository)(nil).SetFactor), arg0)
call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetFactor", reflect.TypeOf((*MockSessionRepository)(nil).SetFactor), factor)
return &MockSessionRepositorySetFactorCall{Call: call}
}
@@ -930,17 +931,17 @@ func (c *MockSessionRepositorySetFactorCall) DoAndReturn(f func(domain.SessionFa
}
// SetLifetime mocks base method.
func (m *MockSessionRepository) SetLifetime(arg0 time.Duration) database.Change {
func (m *MockSessionRepository) SetLifetime(lifetime time.Duration) database.Change {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "SetLifetime", arg0)
ret := m.ctrl.Call(m, "SetLifetime", lifetime)
ret0, _ := ret[0].(database.Change)
return ret0
}
// SetLifetime indicates an expected call of SetLifetime.
func (mr *MockSessionRepositoryMockRecorder) SetLifetime(arg0 any) *MockSessionRepositorySetLifetimeCall {
func (mr *MockSessionRepositoryMockRecorder) SetLifetime(lifetime any) *MockSessionRepositorySetLifetimeCall {
mr.mock.ctrl.T.Helper()
call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetLifetime", reflect.TypeOf((*MockSessionRepository)(nil).SetLifetime), arg0)
call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetLifetime", reflect.TypeOf((*MockSessionRepository)(nil).SetLifetime), lifetime)
return &MockSessionRepositorySetLifetimeCall{Call: call}
}
@@ -968,17 +969,17 @@ func (c *MockSessionRepositorySetLifetimeCall) DoAndReturn(f func(time.Duration)
}
// SetMetadata mocks base method.
func (m *MockSessionRepository) SetMetadata(arg0 []*domain.SessionMetadata) database.Change {
func (m *MockSessionRepository) SetMetadata(metadata []*domain.SessionMetadata) database.Change {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "SetMetadata", arg0)
ret := m.ctrl.Call(m, "SetMetadata", metadata)
ret0, _ := ret[0].(database.Change)
return ret0
}
// SetMetadata indicates an expected call of SetMetadata.
func (mr *MockSessionRepositoryMockRecorder) SetMetadata(arg0 any) *MockSessionRepositorySetMetadataCall {
func (mr *MockSessionRepositoryMockRecorder) SetMetadata(metadata any) *MockSessionRepositorySetMetadataCall {
mr.mock.ctrl.T.Helper()
call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetMetadata", reflect.TypeOf((*MockSessionRepository)(nil).SetMetadata), arg0)
call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetMetadata", reflect.TypeOf((*MockSessionRepository)(nil).SetMetadata), metadata)
return &MockSessionRepositorySetMetadataCall{Call: call}
}
@@ -1006,17 +1007,17 @@ func (c *MockSessionRepositorySetMetadataCall) DoAndReturn(f func([]*domain.Sess
}
// SetToken mocks base method.
func (m *MockSessionRepository) SetToken(arg0 string) database.Change {
func (m *MockSessionRepository) SetToken(token string) database.Change {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "SetToken", arg0)
ret := m.ctrl.Call(m, "SetToken", token)
ret0, _ := ret[0].(database.Change)
return ret0
}
// SetToken indicates an expected call of SetToken.
func (mr *MockSessionRepositoryMockRecorder) SetToken(arg0 any) *MockSessionRepositorySetTokenCall {
func (mr *MockSessionRepositoryMockRecorder) SetToken(token any) *MockSessionRepositorySetTokenCall {
mr.mock.ctrl.T.Helper()
call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetToken", reflect.TypeOf((*MockSessionRepository)(nil).SetToken), arg0)
call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetToken", reflect.TypeOf((*MockSessionRepository)(nil).SetToken), token)
return &MockSessionRepositorySetTokenCall{Call: call}
}
@@ -1044,17 +1045,17 @@ func (c *MockSessionRepositorySetTokenCall) DoAndReturn(f func(string) database.
}
// SetUpdatedAt mocks base method.
func (m *MockSessionRepository) SetUpdatedAt(arg0 time.Time) database.Change {
func (m *MockSessionRepository) SetUpdatedAt(updatedAt time.Time) database.Change {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "SetUpdatedAt", arg0)
ret := m.ctrl.Call(m, "SetUpdatedAt", updatedAt)
ret0, _ := ret[0].(database.Change)
return ret0
}
// SetUpdatedAt indicates an expected call of SetUpdatedAt.
func (mr *MockSessionRepositoryMockRecorder) SetUpdatedAt(arg0 any) *MockSessionRepositorySetUpdatedAtCall {
func (mr *MockSessionRepositoryMockRecorder) SetUpdatedAt(updatedAt any) *MockSessionRepositorySetUpdatedAtCall {
mr.mock.ctrl.T.Helper()
call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetUpdatedAt", reflect.TypeOf((*MockSessionRepository)(nil).SetUpdatedAt), arg0)
call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetUpdatedAt", reflect.TypeOf((*MockSessionRepository)(nil).SetUpdatedAt), updatedAt)
return &MockSessionRepositorySetUpdatedAtCall{Call: call}
}
@@ -1081,49 +1082,49 @@ func (c *MockSessionRepositorySetUpdatedAtCall) DoAndReturn(f func(time.Time) da
return c
}
// TokenColumn mocks base method.
func (m *MockSessionRepository) TokenColumn() database.Column {
// TokenIDColumn mocks base method.
func (m *MockSessionRepository) TokenIDColumn() database.Column {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "TokenColumn")
ret := m.ctrl.Call(m, "TokenIDColumn")
ret0, _ := ret[0].(database.Column)
return ret0
}
// TokenColumn indicates an expected call of TokenColumn.
func (mr *MockSessionRepositoryMockRecorder) TokenColumn() *MockSessionRepositoryTokenColumnCall {
// TokenIDColumn indicates an expected call of TokenIDColumn.
func (mr *MockSessionRepositoryMockRecorder) TokenIDColumn() *MockSessionRepositoryTokenIDColumnCall {
mr.mock.ctrl.T.Helper()
call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TokenColumn", reflect.TypeOf((*MockSessionRepository)(nil).TokenColumn))
return &MockSessionRepositoryTokenColumnCall{Call: call}
call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TokenIDColumn", reflect.TypeOf((*MockSessionRepository)(nil).TokenIDColumn))
return &MockSessionRepositoryTokenIDColumnCall{Call: call}
}
// MockSessionRepositoryTokenColumnCall wrap *gomock.Call
type MockSessionRepositoryTokenColumnCall struct {
// MockSessionRepositoryTokenIDColumnCall wrap *gomock.Call
type MockSessionRepositoryTokenIDColumnCall struct {
*gomock.Call
}
// Return rewrite *gomock.Call.Return
func (c *MockSessionRepositoryTokenColumnCall) Return(arg0 database.Column) *MockSessionRepositoryTokenColumnCall {
func (c *MockSessionRepositoryTokenIDColumnCall) Return(arg0 database.Column) *MockSessionRepositoryTokenIDColumnCall {
c.Call = c.Call.Return(arg0)
return c
}
// Do rewrite *gomock.Call.Do
func (c *MockSessionRepositoryTokenColumnCall) Do(f func() database.Column) *MockSessionRepositoryTokenColumnCall {
func (c *MockSessionRepositoryTokenIDColumnCall) Do(f func() database.Column) *MockSessionRepositoryTokenIDColumnCall {
c.Call = c.Call.Do(f)
return c
}
// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockSessionRepositoryTokenColumnCall) DoAndReturn(f func() database.Column) *MockSessionRepositoryTokenColumnCall {
func (c *MockSessionRepositoryTokenIDColumnCall) DoAndReturn(f func() database.Column) *MockSessionRepositoryTokenIDColumnCall {
c.Call = c.Call.DoAndReturn(f)
return c
}
// Update mocks base method.
func (m *MockSessionRepository) Update(arg0 context.Context, arg1 database.QueryExecutor, arg2 database.Condition, arg3 ...database.Change) (int64, error) {
func (m *MockSessionRepository) Update(ctx context.Context, client database.QueryExecutor, condition database.Condition, changes ...database.Change) (int64, error) {
m.ctrl.T.Helper()
varargs := []any{arg0, arg1, arg2}
for _, a := range arg3 {
varargs := []any{ctx, client, condition}
for _, a := range changes {
varargs = append(varargs, a)
}
ret := m.ctrl.Call(m, "Update", varargs...)
@@ -1133,9 +1134,9 @@ func (m *MockSessionRepository) Update(arg0 context.Context, arg1 database.Query
}
// Update indicates an expected call of Update.
func (mr *MockSessionRepositoryMockRecorder) Update(arg0, arg1, arg2 any, arg3 ...any) *MockSessionRepositoryUpdateCall {
func (mr *MockSessionRepositoryMockRecorder) Update(ctx, client, condition any, changes ...any) *MockSessionRepositoryUpdateCall {
mr.mock.ctrl.T.Helper()
varargs := append([]any{arg0, arg1, arg2}, arg3...)
varargs := append([]any{ctx, client, condition}, changes...)
call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Update", reflect.TypeOf((*MockSessionRepository)(nil).Update), varargs...)
return &MockSessionRepositoryUpdateCall{Call: call}
}
@@ -1202,17 +1203,17 @@ func (c *MockSessionRepositoryUpdatedAtColumnCall) DoAndReturn(f func() database
}
// UpdatedAtCondition mocks base method.
func (m *MockSessionRepository) UpdatedAtCondition(arg0 database.NumberOperation, arg1 time.Time) database.Condition {
func (m *MockSessionRepository) UpdatedAtCondition(op database.NumberOperation, updatedAt time.Time) database.Condition {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "UpdatedAtCondition", arg0, arg1)
ret := m.ctrl.Call(m, "UpdatedAtCondition", op, updatedAt)
ret0, _ := ret[0].(database.Condition)
return ret0
}
// UpdatedAtCondition indicates an expected call of UpdatedAtCondition.
func (mr *MockSessionRepositoryMockRecorder) UpdatedAtCondition(arg0, arg1 any) *MockSessionRepositoryUpdatedAtConditionCall {
func (mr *MockSessionRepositoryMockRecorder) UpdatedAtCondition(op, updatedAt any) *MockSessionRepositoryUpdatedAtConditionCall {
mr.mock.ctrl.T.Helper()
call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdatedAtCondition", reflect.TypeOf((*MockSessionRepository)(nil).UpdatedAtCondition), arg0, arg1)
call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdatedAtCondition", reflect.TypeOf((*MockSessionRepository)(nil).UpdatedAtCondition), op, updatedAt)
return &MockSessionRepositoryUpdatedAtConditionCall{Call: call}
}
@@ -1240,17 +1241,17 @@ func (c *MockSessionRepositoryUpdatedAtConditionCall) DoAndReturn(f func(databas
}
// UserAgentIDCondition mocks base method.
func (m *MockSessionRepository) UserAgentIDCondition(arg0 string) database.Condition {
func (m *MockSessionRepository) UserAgentIDCondition(userAgentID string) database.Condition {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "UserAgentIDCondition", arg0)
ret := m.ctrl.Call(m, "UserAgentIDCondition", userAgentID)
ret0, _ := ret[0].(database.Condition)
return ret0
}
// UserAgentIDCondition indicates an expected call of UserAgentIDCondition.
func (mr *MockSessionRepositoryMockRecorder) UserAgentIDCondition(arg0 any) *MockSessionRepositoryUserAgentIDConditionCall {
func (mr *MockSessionRepositoryMockRecorder) UserAgentIDCondition(userAgentID any) *MockSessionRepositoryUserAgentIDConditionCall {
mr.mock.ctrl.T.Helper()
call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UserAgentIDCondition", reflect.TypeOf((*MockSessionRepository)(nil).UserAgentIDCondition), arg0)
call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UserAgentIDCondition", reflect.TypeOf((*MockSessionRepository)(nil).UserAgentIDCondition), userAgentID)
return &MockSessionRepositoryUserAgentIDConditionCall{Call: call}
}
@@ -1316,17 +1317,17 @@ func (c *MockSessionRepositoryUserIDColumnCall) DoAndReturn(f func() database.Co
}
// UserIDCondition mocks base method.
func (m *MockSessionRepository) UserIDCondition(arg0 string) database.Condition {
func (m *MockSessionRepository) UserIDCondition(userID string) database.Condition {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "UserIDCondition", arg0)
ret := m.ctrl.Call(m, "UserIDCondition", userID)
ret0, _ := ret[0].(database.Condition)
return ret0
}
// UserIDCondition indicates an expected call of UserIDCondition.
func (mr *MockSessionRepositoryMockRecorder) UserIDCondition(arg0 any) *MockSessionRepositoryUserIDConditionCall {
func (mr *MockSessionRepositoryMockRecorder) UserIDCondition(userID any) *MockSessionRepositoryUserIDConditionCall {
mr.mock.ctrl.T.Helper()
call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UserIDCondition", reflect.TypeOf((*MockSessionRepository)(nil).UserIDCondition), arg0)
call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UserIDCondition", reflect.TypeOf((*MockSessionRepository)(nil).UserIDCondition), userID)
return &MockSessionRepositoryUserIDConditionCall{Call: call}
}
backend/v3/domain/mock/user.mock.go
+139 -291
View File
@@ -320,6 +320,44 @@ func (c *MockUserRepositoryHumanCall) DoAndReturn(f func() domain.HumanUserRepos
return c
}
// IDColumn mocks base method.
func (m *MockUserRepository) IDColumn() database.Column {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "IDColumn")
ret0, _ := ret[0].(database.Column)
return ret0
}
// IDColumn indicates an expected call of IDColumn.
func (mr *MockUserRepositoryMockRecorder) IDColumn() *MockUserRepositoryIDColumnCall {
mr.mock.ctrl.T.Helper()
call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IDColumn", reflect.TypeOf((*MockUserRepository)(nil).IDColumn))
return &MockUserRepositoryIDColumnCall{Call: call}
}
// MockUserRepositoryIDColumnCall wrap *gomock.Call
type MockUserRepositoryIDColumnCall struct {
*gomock.Call
}
// Return rewrite *gomock.Call.Return
func (c *MockUserRepositoryIDColumnCall) Return(arg0 database.Column) *MockUserRepositoryIDColumnCall {
c.Call = c.Call.Return(arg0)
return c
}
// Do rewrite *gomock.Call.Do
func (c *MockUserRepositoryIDColumnCall) Do(f func() database.Column) *MockUserRepositoryIDColumnCall {
c.Call = c.Call.Do(f)
return c
}
// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockUserRepositoryIDColumnCall) DoAndReturn(f func() database.Column) *MockUserRepositoryIDColumnCall {
c.Call = c.Call.DoAndReturn(f)
return c
}
// IDCondition mocks base method.
func (m *MockUserRepository) IDCondition(userID string) database.Condition {
m.ctrl.T.Helper()
@@ -358,6 +396,44 @@ func (c *MockUserRepositoryIDConditionCall) DoAndReturn(f func(string) database.
return c
}
// InstanceIDColumn mocks base method.
func (m *MockUserRepository) InstanceIDColumn() database.Column {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "InstanceIDColumn")
ret0, _ := ret[0].(database.Column)
return ret0
}
// InstanceIDColumn indicates an expected call of InstanceIDColumn.
func (mr *MockUserRepositoryMockRecorder) InstanceIDColumn() *MockUserRepositoryInstanceIDColumnCall {
mr.mock.ctrl.T.Helper()
call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InstanceIDColumn", reflect.TypeOf((*MockUserRepository)(nil).InstanceIDColumn))
return &MockUserRepositoryInstanceIDColumnCall{Call: call}
}
// MockUserRepositoryInstanceIDColumnCall wrap *gomock.Call
type MockUserRepositoryInstanceIDColumnCall struct {
*gomock.Call
}
// Return rewrite *gomock.Call.Return
func (c *MockUserRepositoryInstanceIDColumnCall) Return(arg0 database.Column) *MockUserRepositoryInstanceIDColumnCall {
c.Call = c.Call.Return(arg0)
return c
}
// Do rewrite *gomock.Call.Do
func (c *MockUserRepositoryInstanceIDColumnCall) Do(f func() database.Column) *MockUserRepositoryInstanceIDColumnCall {
c.Call = c.Call.Do(f)
return c
}
// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockUserRepositoryInstanceIDColumnCall) DoAndReturn(f func() database.Column) *MockUserRepositoryInstanceIDColumnCall {
c.Call = c.Call.DoAndReturn(f)
return c
}
// InstanceIDCondition mocks base method.
func (m *MockUserRepository) InstanceIDCondition(instanceID string) database.Condition {
m.ctrl.T.Helper()
@@ -440,234 +516,6 @@ func (c *MockUserRepositoryListCall) DoAndReturn(f func(context.Context, databas
return c
}
// LoadIdentityProviderLinks mocks base method.
func (m *MockUserRepository) LoadIdentityProviderLinks() domain.UserRepository {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "LoadIdentityProviderLinks")
ret0, _ := ret[0].(domain.UserRepository)
return ret0
}
// LoadIdentityProviderLinks indicates an expected call of LoadIdentityProviderLinks.
func (mr *MockUserRepositoryMockRecorder) LoadIdentityProviderLinks() *MockUserRepositoryLoadIdentityProviderLinksCall {
mr.mock.ctrl.T.Helper()
call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LoadIdentityProviderLinks", reflect.TypeOf((*MockUserRepository)(nil).LoadIdentityProviderLinks))
return &MockUserRepositoryLoadIdentityProviderLinksCall{Call: call}
}
// MockUserRepositoryLoadIdentityProviderLinksCall wrap *gomock.Call
type MockUserRepositoryLoadIdentityProviderLinksCall struct {
*gomock.Call
}
// Return rewrite *gomock.Call.Return
func (c *MockUserRepositoryLoadIdentityProviderLinksCall) Return(arg0 domain.UserRepository) *MockUserRepositoryLoadIdentityProviderLinksCall {
c.Call = c.Call.Return(arg0)
return c
}
// Do rewrite *gomock.Call.Do
func (c *MockUserRepositoryLoadIdentityProviderLinksCall) Do(f func() domain.UserRepository) *MockUserRepositoryLoadIdentityProviderLinksCall {
c.Call = c.Call.Do(f)
return c
}
// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockUserRepositoryLoadIdentityProviderLinksCall) DoAndReturn(f func() domain.UserRepository) *MockUserRepositoryLoadIdentityProviderLinksCall {
c.Call = c.Call.DoAndReturn(f)
return c
}
// LoadKeys mocks base method.
func (m *MockUserRepository) LoadKeys() domain.UserRepository {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "LoadKeys")
ret0, _ := ret[0].(domain.UserRepository)
return ret0
}
// LoadKeys indicates an expected call of LoadKeys.
func (mr *MockUserRepositoryMockRecorder) LoadKeys() *MockUserRepositoryLoadKeysCall {
mr.mock.ctrl.T.Helper()
call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LoadKeys", reflect.TypeOf((*MockUserRepository)(nil).LoadKeys))
return &MockUserRepositoryLoadKeysCall{Call: call}
}
// MockUserRepositoryLoadKeysCall wrap *gomock.Call
type MockUserRepositoryLoadKeysCall struct {
*gomock.Call
}
// Return rewrite *gomock.Call.Return
func (c *MockUserRepositoryLoadKeysCall) Return(arg0 domain.UserRepository) *MockUserRepositoryLoadKeysCall {
c.Call = c.Call.Return(arg0)
return c
}
// Do rewrite *gomock.Call.Do
func (c *MockUserRepositoryLoadKeysCall) Do(f func() domain.UserRepository) *MockUserRepositoryLoadKeysCall {
c.Call = c.Call.Do(f)
return c
}
// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockUserRepositoryLoadKeysCall) DoAndReturn(f func() domain.UserRepository) *MockUserRepositoryLoadKeysCall {
c.Call = c.Call.DoAndReturn(f)
return c
}
// LoadMetadata mocks base method.
func (m *MockUserRepository) LoadMetadata() domain.UserRepository {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "LoadMetadata")
ret0, _ := ret[0].(domain.UserRepository)
return ret0
}
// LoadMetadata indicates an expected call of LoadMetadata.
func (mr *MockUserRepositoryMockRecorder) LoadMetadata() *MockUserRepositoryLoadMetadataCall {
mr.mock.ctrl.T.Helper()
call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LoadMetadata", reflect.TypeOf((*MockUserRepository)(nil).LoadMetadata))
return &MockUserRepositoryLoadMetadataCall{Call: call}
}
// MockUserRepositoryLoadMetadataCall wrap *gomock.Call
type MockUserRepositoryLoadMetadataCall struct {
*gomock.Call
}
// Return rewrite *gomock.Call.Return
func (c *MockUserRepositoryLoadMetadataCall) Return(arg0 domain.UserRepository) *MockUserRepositoryLoadMetadataCall {
c.Call = c.Call.Return(arg0)
return c
}
// Do rewrite *gomock.Call.Do
func (c *MockUserRepositoryLoadMetadataCall) Do(f func() domain.UserRepository) *MockUserRepositoryLoadMetadataCall {
c.Call = c.Call.Do(f)
return c
}
// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockUserRepositoryLoadMetadataCall) DoAndReturn(f func() domain.UserRepository) *MockUserRepositoryLoadMetadataCall {
c.Call = c.Call.DoAndReturn(f)
return c
}
// LoadPATs mocks base method.
func (m *MockUserRepository) LoadPATs() domain.UserRepository {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "LoadPATs")
ret0, _ := ret[0].(domain.UserRepository)
return ret0
}
// LoadPATs indicates an expected call of LoadPATs.
func (mr *MockUserRepositoryMockRecorder) LoadPATs() *MockUserRepositoryLoadPATsCall {
mr.mock.ctrl.T.Helper()
call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LoadPATs", reflect.TypeOf((*MockUserRepository)(nil).LoadPATs))
return &MockUserRepositoryLoadPATsCall{Call: call}
}
// MockUserRepositoryLoadPATsCall wrap *gomock.Call
type MockUserRepositoryLoadPATsCall struct {
*gomock.Call
}
// Return rewrite *gomock.Call.Return
func (c *MockUserRepositoryLoadPATsCall) Return(arg0 domain.UserRepository) *MockUserRepositoryLoadPATsCall {
c.Call = c.Call.Return(arg0)
return c
}
// Do rewrite *gomock.Call.Do
func (c *MockUserRepositoryLoadPATsCall) Do(f func() domain.UserRepository) *MockUserRepositoryLoadPATsCall {
c.Call = c.Call.Do(f)
return c
}
// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockUserRepositoryLoadPATsCall) DoAndReturn(f func() domain.UserRepository) *MockUserRepositoryLoadPATsCall {
c.Call = c.Call.DoAndReturn(f)
return c
}
// LoadPasskeys mocks base method.
func (m *MockUserRepository) LoadPasskeys() domain.UserRepository {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "LoadPasskeys")
ret0, _ := ret[0].(domain.UserRepository)
return ret0
}
// LoadPasskeys indicates an expected call of LoadPasskeys.
func (mr *MockUserRepositoryMockRecorder) LoadPasskeys() *MockUserRepositoryLoadPasskeysCall {
mr.mock.ctrl.T.Helper()
call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LoadPasskeys", reflect.TypeOf((*MockUserRepository)(nil).LoadPasskeys))
return &MockUserRepositoryLoadPasskeysCall{Call: call}
}
// MockUserRepositoryLoadPasskeysCall wrap *gomock.Call
type MockUserRepositoryLoadPasskeysCall struct {
*gomock.Call
}
// Return rewrite *gomock.Call.Return
func (c *MockUserRepositoryLoadPasskeysCall) Return(arg0 domain.UserRepository) *MockUserRepositoryLoadPasskeysCall {
c.Call = c.Call.Return(arg0)
return c
}
// Do rewrite *gomock.Call.Do
func (c *MockUserRepositoryLoadPasskeysCall) Do(f func() domain.UserRepository) *MockUserRepositoryLoadPasskeysCall {
c.Call = c.Call.Do(f)
return c
}
// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockUserRepositoryLoadPasskeysCall) DoAndReturn(f func() domain.UserRepository) *MockUserRepositoryLoadPasskeysCall {
c.Call = c.Call.DoAndReturn(f)
return c
}
// LoadVerifications mocks base method.
func (m *MockUserRepository) LoadVerifications() domain.UserRepository {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "LoadVerifications")
ret0, _ := ret[0].(domain.UserRepository)
return ret0
}
// LoadVerifications indicates an expected call of LoadVerifications.
func (mr *MockUserRepositoryMockRecorder) LoadVerifications() *MockUserRepositoryLoadVerificationsCall {
mr.mock.ctrl.T.Helper()
call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LoadVerifications", reflect.TypeOf((*MockUserRepository)(nil).LoadVerifications))
return &MockUserRepositoryLoadVerificationsCall{Call: call}
}
// MockUserRepositoryLoadVerificationsCall wrap *gomock.Call
type MockUserRepositoryLoadVerificationsCall struct {
*gomock.Call
}
// Return rewrite *gomock.Call.Return
func (c *MockUserRepositoryLoadVerificationsCall) Return(arg0 domain.UserRepository) *MockUserRepositoryLoadVerificationsCall {
c.Call = c.Call.Return(arg0)
return c
}
// Do rewrite *gomock.Call.Do
func (c *MockUserRepositoryLoadVerificationsCall) Do(f func() domain.UserRepository) *MockUserRepositoryLoadVerificationsCall {
c.Call = c.Call.Do(f)
return c
}
// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockUserRepositoryLoadVerificationsCall) DoAndReturn(f func() domain.UserRepository) *MockUserRepositoryLoadVerificationsCall {
c.Call = c.Call.DoAndReturn(f)
return c
}
// LoginNameCondition mocks base method.
func (m *MockUserRepository) LoginNameCondition(op database.TextOperation, loginName string) database.Condition {
m.ctrl.T.Helper()
@@ -744,116 +592,78 @@ func (c *MockUserRepositoryMachineCall) DoAndReturn(f func() domain.MachineUserR
return c
}
// MetadataKeyCondition mocks base method.
func (m *MockUserRepository) MetadataKeyCondition(key string) database.Condition {
// MetadataConditions mocks base method.
func (m *MockUserRepository) MetadataConditions() domain.UserMetadataConditions {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "MetadataKeyCondition", key)
ret0, _ := ret[0].(database.Condition)
ret := m.ctrl.Call(m, "MetadataConditions")
ret0, _ := ret[0].(domain.UserMetadataConditions)
return ret0
}
// MetadataKeyCondition indicates an expected call of MetadataKeyCondition.
func (mr *MockUserRepositoryMockRecorder) MetadataKeyCondition(key any) *MockUserRepositoryMetadataKeyConditionCall {
// MetadataConditions indicates an expected call of MetadataConditions.
func (mr *MockUserRepositoryMockRecorder) MetadataConditions() *MockUserRepositoryMetadataConditionsCall {
mr.mock.ctrl.T.Helper()
call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "MetadataKeyCondition", reflect.TypeOf((*MockUserRepository)(nil).MetadataKeyCondition), key)
return &MockUserRepositoryMetadataKeyConditionCall{Call: call}
call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "MetadataConditions", reflect.TypeOf((*MockUserRepository)(nil).MetadataConditions))
return &MockUserRepositoryMetadataConditionsCall{Call: call}
}
// MockUserRepositoryMetadataKeyConditionCall wrap *gomock.Call
type MockUserRepositoryMetadataKeyConditionCall struct {
// MockUserRepositoryMetadataConditionsCall wrap *gomock.Call
type MockUserRepositoryMetadataConditionsCall struct {
*gomock.Call
}
// Return rewrite *gomock.Call.Return
func (c *MockUserRepositoryMetadataKeyConditionCall) Return(arg0 database.Condition) *MockUserRepositoryMetadataKeyConditionCall {
func (c *MockUserRepositoryMetadataConditionsCall) Return(arg0 domain.UserMetadataConditions) *MockUserRepositoryMetadataConditionsCall {
c.Call = c.Call.Return(arg0)
return c
}
// Do rewrite *gomock.Call.Do
func (c *MockUserRepositoryMetadataKeyConditionCall) Do(f func(string) database.Condition) *MockUserRepositoryMetadataKeyConditionCall {
func (c *MockUserRepositoryMetadataConditionsCall) Do(f func() domain.UserMetadataConditions) *MockUserRepositoryMetadataConditionsCall {
c.Call = c.Call.Do(f)
return c
}
// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockUserRepositoryMetadataKeyConditionCall) DoAndReturn(f func(string) database.Condition) *MockUserRepositoryMetadataKeyConditionCall {
func (c *MockUserRepositoryMetadataConditionsCall) DoAndReturn(f func() domain.UserMetadataConditions) *MockUserRepositoryMetadataConditionsCall {
c.Call = c.Call.DoAndReturn(f)
return c
}
// MetadataValueCondition mocks base method.
func (m *MockUserRepository) MetadataValueCondition(op database.BytesOperation, value []byte) database.Condition {
// OrganizationIDCondition mocks base method.
func (m *MockUserRepository) OrganizationIDCondition(orgID string) database.Condition {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "MetadataValueCondition", op, value)
ret := m.ctrl.Call(m, "OrganizationIDCondition", orgID)
ret0, _ := ret[0].(database.Condition)
return ret0
}
// MetadataValueCondition indicates an expected call of MetadataValueCondition.
func (mr *MockUserRepositoryMockRecorder) MetadataValueCondition(op, value any) *MockUserRepositoryMetadataValueConditionCall {
// OrganizationIDCondition indicates an expected call of OrganizationIDCondition.
func (mr *MockUserRepositoryMockRecorder) OrganizationIDCondition(orgID any) *MockUserRepositoryOrganizationIDConditionCall {
mr.mock.ctrl.T.Helper()
call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "MetadataValueCondition", reflect.TypeOf((*MockUserRepository)(nil).MetadataValueCondition), op, value)
return &MockUserRepositoryMetadataValueConditionCall{Call: call}
call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "OrganizationIDCondition", reflect.TypeOf((*MockUserRepository)(nil).OrganizationIDCondition), orgID)
return &MockUserRepositoryOrganizationIDConditionCall{Call: call}
}
// MockUserRepositoryMetadataValueConditionCall wrap *gomock.Call
type MockUserRepositoryMetadataValueConditionCall struct {
// MockUserRepositoryOrganizationIDConditionCall wrap *gomock.Call
type MockUserRepositoryOrganizationIDConditionCall struct {
*gomock.Call
}
// Return rewrite *gomock.Call.Return
func (c *MockUserRepositoryMetadataValueConditionCall) Return(arg0 database.Condition) *MockUserRepositoryMetadataValueConditionCall {
func (c *MockUserRepositoryOrganizationIDConditionCall) Return(arg0 database.Condition) *MockUserRepositoryOrganizationIDConditionCall {
c.Call = c.Call.Return(arg0)
return c
}
// Do rewrite *gomock.Call.Do
func (c *MockUserRepositoryMetadataValueConditionCall) Do(f func(database.BytesOperation, []byte) database.Condition) *MockUserRepositoryMetadataValueConditionCall {
func (c *MockUserRepositoryOrganizationIDConditionCall) Do(f func(string) database.Condition) *MockUserRepositoryOrganizationIDConditionCall {
c.Call = c.Call.Do(f)
return c
}
// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockUserRepositoryMetadataValueConditionCall) DoAndReturn(f func(database.BytesOperation, []byte) database.Condition) *MockUserRepositoryMetadataValueConditionCall {
c.Call = c.Call.DoAndReturn(f)
return c
}
// OrgIDCondition mocks base method.
func (m *MockUserRepository) OrgIDCondition(orgID string) database.Condition {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "OrgIDCondition", orgID)
ret0, _ := ret[0].(database.Condition)
return ret0
}
// OrgIDCondition indicates an expected call of OrgIDCondition.
func (mr *MockUserRepositoryMockRecorder) OrgIDCondition(orgID any) *MockUserRepositoryOrgIDConditionCall {
mr.mock.ctrl.T.Helper()
call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "OrgIDCondition", reflect.TypeOf((*MockUserRepository)(nil).OrgIDCondition), orgID)
return &MockUserRepositoryOrgIDConditionCall{Call: call}
}
// MockUserRepositoryOrgIDConditionCall wrap *gomock.Call
type MockUserRepositoryOrgIDConditionCall struct {
*gomock.Call
}
// Return rewrite *gomock.Call.Return
func (c *MockUserRepositoryOrgIDConditionCall) Return(arg0 database.Condition) *MockUserRepositoryOrgIDConditionCall {
c.Call = c.Call.Return(arg0)
return c
}
// Do rewrite *gomock.Call.Do
func (c *MockUserRepositoryOrgIDConditionCall) Do(f func(string) database.Condition) *MockUserRepositoryOrgIDConditionCall {
c.Call = c.Call.Do(f)
return c
}
// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockUserRepositoryOrgIDConditionCall) DoAndReturn(f func(string) database.Condition) *MockUserRepositoryOrgIDConditionCall {
func (c *MockUserRepositoryOrganizationIDConditionCall) DoAndReturn(f func(string) database.Condition) *MockUserRepositoryOrganizationIDConditionCall {
c.Call = c.Call.DoAndReturn(f)
return c
}
@@ -1162,6 +972,44 @@ func (c *MockUserRepositoryStateConditionCall) DoAndReturn(f func(domain.UserSta
return c
}
// TypeColumn mocks base method.
func (m *MockUserRepository) TypeColumn() database.Column {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "TypeColumn")
ret0, _ := ret[0].(database.Column)
return ret0
}
// TypeColumn indicates an expected call of TypeColumn.
func (mr *MockUserRepositoryMockRecorder) TypeColumn() *MockUserRepositoryTypeColumnCall {
mr.mock.ctrl.T.Helper()
call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TypeColumn", reflect.TypeOf((*MockUserRepository)(nil).TypeColumn))
return &MockUserRepositoryTypeColumnCall{Call: call}
}
// MockUserRepositoryTypeColumnCall wrap *gomock.Call
type MockUserRepositoryTypeColumnCall struct {
*gomock.Call
}
// Return rewrite *gomock.Call.Return
func (c *MockUserRepositoryTypeColumnCall) Return(arg0 database.Column) *MockUserRepositoryTypeColumnCall {
c.Call = c.Call.Return(arg0)
return c
}
// Do rewrite *gomock.Call.Do
func (c *MockUserRepositoryTypeColumnCall) Do(f func() database.Column) *MockUserRepositoryTypeColumnCall {
c.Call = c.Call.Do(f)
return c
}
// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockUserRepositoryTypeColumnCall) DoAndReturn(f func() database.Column) *MockUserRepositoryTypeColumnCall {
c.Call = c.Call.DoAndReturn(f)
return c
}
// TypeCondition mocks base method.
func (m *MockUserRepository) TypeCondition(userType domain.UserType) database.Condition {
m.ctrl.T.Helper()
backend/v3/domain/mock/user_identity_provider_link.mock.go
+899
View File
@@ -0,0 +1,899 @@
// Code generated by MockGen. DO NOT EDIT.
// Source: github.com/zitadel/zitadel/backend/v3/domain (interfaces: UserIdentityProviderLinkRepository)
//
// Generated by this command:
//
// mockgen -typed -package domainmock -destination ./mock/user_identity_provider_link.mock.go . UserIdentityProviderLinkRepository
//
// Package domainmock is a generated GoMock package.
package domainmock
import (
context "context"
reflect "reflect"
time "time"
domain "github.com/zitadel/zitadel/backend/v3/domain"
database "github.com/zitadel/zitadel/backend/v3/storage/database"
gomock "go.uber.org/mock/gomock"
)
// MockUserIdentityProviderLinkRepository is a mock of UserIdentityProviderLinkRepository interface.
type MockUserIdentityProviderLinkRepository struct {
ctrl *gomock.Controller
recorder *MockUserIdentityProviderLinkRepositoryMockRecorder
isgomock struct{}
}
// MockUserIdentityProviderLinkRepositoryMockRecorder is the mock recorder for MockUserIdentityProviderLinkRepository.
type MockUserIdentityProviderLinkRepositoryMockRecorder struct {
mock *MockUserIdentityProviderLinkRepository
}
// NewMockUserIdentityProviderLinkRepository creates a new mock instance.
func NewMockUserIdentityProviderLinkRepository(ctrl *gomock.Controller) *MockUserIdentityProviderLinkRepository {
mock := &MockUserIdentityProviderLinkRepository{ctrl: ctrl}
mock.recorder = &MockUserIdentityProviderLinkRepositoryMockRecorder{mock}
return mock
}
// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockUserIdentityProviderLinkRepository) EXPECT() *MockUserIdentityProviderLinkRepositoryMockRecorder {
return m.recorder
}
// Create mocks base method.
func (m *MockUserIdentityProviderLinkRepository) Create(ctx context.Context, client database.QueryExecutor, link *domain.UserIdentityProviderLink) error {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "Create", ctx, client, link)
ret0, _ := ret[0].(error)
return ret0
}
// Create indicates an expected call of Create.
func (mr *MockUserIdentityProviderLinkRepositoryMockRecorder) Create(ctx, client, link any) *MockUserIdentityProviderLinkRepositoryCreateCall {
mr.mock.ctrl.T.Helper()
call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Create", reflect.TypeOf((*MockUserIdentityProviderLinkRepository)(nil).Create), ctx, client, link)
return &MockUserIdentityProviderLinkRepositoryCreateCall{Call: call}
}
// MockUserIdentityProviderLinkRepositoryCreateCall wrap *gomock.Call
type MockUserIdentityProviderLinkRepositoryCreateCall struct {
*gomock.Call
}
// Return rewrite *gomock.Call.Return
func (c *MockUserIdentityProviderLinkRepositoryCreateCall) Return(arg0 error) *MockUserIdentityProviderLinkRepositoryCreateCall {
c.Call = c.Call.Return(arg0)
return c
}
// Do rewrite *gomock.Call.Do
func (c *MockUserIdentityProviderLinkRepositoryCreateCall) Do(f func(context.Context, database.QueryExecutor, *domain.UserIdentityProviderLink) error) *MockUserIdentityProviderLinkRepositoryCreateCall {
c.Call = c.Call.Do(f)
return c
}
// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockUserIdentityProviderLinkRepositoryCreateCall) DoAndReturn(f func(context.Context, database.QueryExecutor, *domain.UserIdentityProviderLink) error) *MockUserIdentityProviderLinkRepositoryCreateCall {
c.Call = c.Call.DoAndReturn(f)
return c
}
// CreatedAtColumn mocks base method.
func (m *MockUserIdentityProviderLinkRepository) CreatedAtColumn() database.Column {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "CreatedAtColumn")
ret0, _ := ret[0].(database.Column)
return ret0
}
// CreatedAtColumn indicates an expected call of CreatedAtColumn.
func (mr *MockUserIdentityProviderLinkRepositoryMockRecorder) CreatedAtColumn() *MockUserIdentityProviderLinkRepositoryCreatedAtColumnCall {
mr.mock.ctrl.T.Helper()
call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreatedAtColumn", reflect.TypeOf((*MockUserIdentityProviderLinkRepository)(nil).CreatedAtColumn))
return &MockUserIdentityProviderLinkRepositoryCreatedAtColumnCall{Call: call}
}
// MockUserIdentityProviderLinkRepositoryCreatedAtColumnCall wrap *gomock.Call
type MockUserIdentityProviderLinkRepositoryCreatedAtColumnCall struct {
*gomock.Call
}
// Return rewrite *gomock.Call.Return
func (c *MockUserIdentityProviderLinkRepositoryCreatedAtColumnCall) Return(arg0 database.Column) *MockUserIdentityProviderLinkRepositoryCreatedAtColumnCall {
c.Call = c.Call.Return(arg0)
return c
}
// Do rewrite *gomock.Call.Do
func (c *MockUserIdentityProviderLinkRepositoryCreatedAtColumnCall) Do(f func() database.Column) *MockUserIdentityProviderLinkRepositoryCreatedAtColumnCall {
c.Call = c.Call.Do(f)
return c
}
// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockUserIdentityProviderLinkRepositoryCreatedAtColumnCall) DoAndReturn(f func() database.Column) *MockUserIdentityProviderLinkRepositoryCreatedAtColumnCall {
c.Call = c.Call.DoAndReturn(f)
return c
}
// Delete mocks base method.
func (m *MockUserIdentityProviderLinkRepository) Delete(ctx context.Context, client database.QueryExecutor, condition database.Condition) (int64, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "Delete", ctx, client, condition)
ret0, _ := ret[0].(int64)
ret1, _ := ret[1].(error)
return ret0, ret1
}
// Delete indicates an expected call of Delete.
func (mr *MockUserIdentityProviderLinkRepositoryMockRecorder) Delete(ctx, client, condition any) *MockUserIdentityProviderLinkRepositoryDeleteCall {
mr.mock.ctrl.T.Helper()
call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Delete", reflect.TypeOf((*MockUserIdentityProviderLinkRepository)(nil).Delete), ctx, client, condition)
return &MockUserIdentityProviderLinkRepositoryDeleteCall{Call: call}
}
// MockUserIdentityProviderLinkRepositoryDeleteCall wrap *gomock.Call
type MockUserIdentityProviderLinkRepositoryDeleteCall struct {
*gomock.Call
}
// Return rewrite *gomock.Call.Return
func (c *MockUserIdentityProviderLinkRepositoryDeleteCall) Return(arg0 int64, arg1 error) *MockUserIdentityProviderLinkRepositoryDeleteCall {
c.Call = c.Call.Return(arg0, arg1)
return c
}
// Do rewrite *gomock.Call.Do
func (c *MockUserIdentityProviderLinkRepositoryDeleteCall) Do(f func(context.Context, database.QueryExecutor, database.Condition) (int64, error)) *MockUserIdentityProviderLinkRepositoryDeleteCall {
c.Call = c.Call.Do(f)
return c
}
// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockUserIdentityProviderLinkRepositoryDeleteCall) DoAndReturn(f func(context.Context, database.QueryExecutor, database.Condition) (int64, error)) *MockUserIdentityProviderLinkRepositoryDeleteCall {
c.Call = c.Call.DoAndReturn(f)
return c
}
// Get mocks base method.
func (m *MockUserIdentityProviderLinkRepository) Get(ctx context.Context, client database.QueryExecutor, condition database.Condition, opts ...database.QueryOption) (*domain.UserIdentityProviderLink, error) {
m.ctrl.T.Helper()
varargs := []any{ctx, client, condition}
for _, a := range opts {
varargs = append(varargs, a)
}
ret := m.ctrl.Call(m, "Get", varargs...)
ret0, _ := ret[0].(*domain.UserIdentityProviderLink)
ret1, _ := ret[1].(error)
return ret0, ret1
}
// Get indicates an expected call of Get.
func (mr *MockUserIdentityProviderLinkRepositoryMockRecorder) Get(ctx, client, condition any, opts ...any) *MockUserIdentityProviderLinkRepositoryGetCall {
mr.mock.ctrl.T.Helper()
varargs := append([]any{ctx, client, condition}, opts...)
call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Get", reflect.TypeOf((*MockUserIdentityProviderLinkRepository)(nil).Get), varargs...)
return &MockUserIdentityProviderLinkRepositoryGetCall{Call: call}
}
// MockUserIdentityProviderLinkRepositoryGetCall wrap *gomock.Call
type MockUserIdentityProviderLinkRepositoryGetCall struct {
*gomock.Call
}
// Return rewrite *gomock.Call.Return
func (c *MockUserIdentityProviderLinkRepositoryGetCall) Return(arg0 *domain.UserIdentityProviderLink, arg1 error) *MockUserIdentityProviderLinkRepositoryGetCall {
c.Call = c.Call.Return(arg0, arg1)
return c
}
// Do rewrite *gomock.Call.Do
func (c *MockUserIdentityProviderLinkRepositoryGetCall) Do(f func(context.Context, database.QueryExecutor, database.Condition, ...database.QueryOption) (*domain.UserIdentityProviderLink, error)) *MockUserIdentityProviderLinkRepositoryGetCall {
c.Call = c.Call.Do(f)
return c
}
// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockUserIdentityProviderLinkRepositoryGetCall) DoAndReturn(f func(context.Context, database.QueryExecutor, database.Condition, ...database.QueryOption) (*domain.UserIdentityProviderLink, error)) *MockUserIdentityProviderLinkRepositoryGetCall {
c.Call = c.Call.DoAndReturn(f)
return c
}
// IdentityProviderIDColumn mocks base method.
func (m *MockUserIdentityProviderLinkRepository) IdentityProviderIDColumn() database.Column {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "IdentityProviderIDColumn")
ret0, _ := ret[0].(database.Column)
return ret0
}
// IdentityProviderIDColumn indicates an expected call of IdentityProviderIDColumn.
func (mr *MockUserIdentityProviderLinkRepositoryMockRecorder) IdentityProviderIDColumn() *MockUserIdentityProviderLinkRepositoryIdentityProviderIDColumnCall {
mr.mock.ctrl.T.Helper()
call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IdentityProviderIDColumn", reflect.TypeOf((*MockUserIdentityProviderLinkRepository)(nil).IdentityProviderIDColumn))
return &MockUserIdentityProviderLinkRepositoryIdentityProviderIDColumnCall{Call: call}
}
// MockUserIdentityProviderLinkRepositoryIdentityProviderIDColumnCall wrap *gomock.Call
type MockUserIdentityProviderLinkRepositoryIdentityProviderIDColumnCall struct {
*gomock.Call
}
// Return rewrite *gomock.Call.Return
func (c *MockUserIdentityProviderLinkRepositoryIdentityProviderIDColumnCall) Return(arg0 database.Column) *MockUserIdentityProviderLinkRepositoryIdentityProviderIDColumnCall {
c.Call = c.Call.Return(arg0)
return c
}
// Do rewrite *gomock.Call.Do
func (c *MockUserIdentityProviderLinkRepositoryIdentityProviderIDColumnCall) Do(f func() database.Column) *MockUserIdentityProviderLinkRepositoryIdentityProviderIDColumnCall {
c.Call = c.Call.Do(f)
return c
}
// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockUserIdentityProviderLinkRepositoryIdentityProviderIDColumnCall) DoAndReturn(f func() database.Column) *MockUserIdentityProviderLinkRepositoryIdentityProviderIDColumnCall {
c.Call = c.Call.DoAndReturn(f)
return c
}
// IdentityProviderIDCondition mocks base method.
func (m *MockUserIdentityProviderLinkRepository) IdentityProviderIDCondition(op database.TextOperation, id string) database.Condition {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "IdentityProviderIDCondition", op, id)
ret0, _ := ret[0].(database.Condition)
return ret0
}
// IdentityProviderIDCondition indicates an expected call of IdentityProviderIDCondition.
func (mr *MockUserIdentityProviderLinkRepositoryMockRecorder) IdentityProviderIDCondition(op, id any) *MockUserIdentityProviderLinkRepositoryIdentityProviderIDConditionCall {
mr.mock.ctrl.T.Helper()
call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IdentityProviderIDCondition", reflect.TypeOf((*MockUserIdentityProviderLinkRepository)(nil).IdentityProviderIDCondition), op, id)
return &MockUserIdentityProviderLinkRepositoryIdentityProviderIDConditionCall{Call: call}
}
// MockUserIdentityProviderLinkRepositoryIdentityProviderIDConditionCall wrap *gomock.Call
type MockUserIdentityProviderLinkRepositoryIdentityProviderIDConditionCall struct {
*gomock.Call
}
// Return rewrite *gomock.Call.Return
func (c *MockUserIdentityProviderLinkRepositoryIdentityProviderIDConditionCall) Return(arg0 database.Condition) *MockUserIdentityProviderLinkRepositoryIdentityProviderIDConditionCall {
c.Call = c.Call.Return(arg0)
return c
}
// Do rewrite *gomock.Call.Do
func (c *MockUserIdentityProviderLinkRepositoryIdentityProviderIDConditionCall) Do(f func(database.TextOperation, string) database.Condition) *MockUserIdentityProviderLinkRepositoryIdentityProviderIDConditionCall {
c.Call = c.Call.Do(f)
return c
}
// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockUserIdentityProviderLinkRepositoryIdentityProviderIDConditionCall) DoAndReturn(f func(database.TextOperation, string) database.Condition) *MockUserIdentityProviderLinkRepositoryIdentityProviderIDConditionCall {
c.Call = c.Call.DoAndReturn(f)
return c
}
// InstanceIDColumn mocks base method.
func (m *MockUserIdentityProviderLinkRepository) InstanceIDColumn() database.Column {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "InstanceIDColumn")
ret0, _ := ret[0].(database.Column)
return ret0
}
// InstanceIDColumn indicates an expected call of InstanceIDColumn.
func (mr *MockUserIdentityProviderLinkRepositoryMockRecorder) InstanceIDColumn() *MockUserIdentityProviderLinkRepositoryInstanceIDColumnCall {
mr.mock.ctrl.T.Helper()
call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InstanceIDColumn", reflect.TypeOf((*MockUserIdentityProviderLinkRepository)(nil).InstanceIDColumn))
return &MockUserIdentityProviderLinkRepositoryInstanceIDColumnCall{Call: call}
}
// MockUserIdentityProviderLinkRepositoryInstanceIDColumnCall wrap *gomock.Call
type MockUserIdentityProviderLinkRepositoryInstanceIDColumnCall struct {
*gomock.Call
}
// Return rewrite *gomock.Call.Return
func (c *MockUserIdentityProviderLinkRepositoryInstanceIDColumnCall) Return(arg0 database.Column) *MockUserIdentityProviderLinkRepositoryInstanceIDColumnCall {
c.Call = c.Call.Return(arg0)
return c
}
// Do rewrite *gomock.Call.Do
func (c *MockUserIdentityProviderLinkRepositoryInstanceIDColumnCall) Do(f func() database.Column) *MockUserIdentityProviderLinkRepositoryInstanceIDColumnCall {
c.Call = c.Call.Do(f)
return c
}
// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockUserIdentityProviderLinkRepositoryInstanceIDColumnCall) DoAndReturn(f func() database.Column) *MockUserIdentityProviderLinkRepositoryInstanceIDColumnCall {
c.Call = c.Call.DoAndReturn(f)
return c
}
// InstanceIDCondition mocks base method.
func (m *MockUserIdentityProviderLinkRepository) InstanceIDCondition(op database.TextOperation, id string) database.Condition {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "InstanceIDCondition", op, id)
ret0, _ := ret[0].(database.Condition)
return ret0
}
// InstanceIDCondition indicates an expected call of InstanceIDCondition.
func (mr *MockUserIdentityProviderLinkRepositoryMockRecorder) InstanceIDCondition(op, id any) *MockUserIdentityProviderLinkRepositoryInstanceIDConditionCall {
mr.mock.ctrl.T.Helper()
call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InstanceIDCondition", reflect.TypeOf((*MockUserIdentityProviderLinkRepository)(nil).InstanceIDCondition), op, id)
return &MockUserIdentityProviderLinkRepositoryInstanceIDConditionCall{Call: call}
}
// MockUserIdentityProviderLinkRepositoryInstanceIDConditionCall wrap *gomock.Call
type MockUserIdentityProviderLinkRepositoryInstanceIDConditionCall struct {
*gomock.Call
}
// Return rewrite *gomock.Call.Return
func (c *MockUserIdentityProviderLinkRepositoryInstanceIDConditionCall) Return(arg0 database.Condition) *MockUserIdentityProviderLinkRepositoryInstanceIDConditionCall {
c.Call = c.Call.Return(arg0)
return c
}
// Do rewrite *gomock.Call.Do
func (c *MockUserIdentityProviderLinkRepositoryInstanceIDConditionCall) Do(f func(database.TextOperation, string) database.Condition) *MockUserIdentityProviderLinkRepositoryInstanceIDConditionCall {
c.Call = c.Call.Do(f)
return c
}
// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockUserIdentityProviderLinkRepositoryInstanceIDConditionCall) DoAndReturn(f func(database.TextOperation, string) database.Condition) *MockUserIdentityProviderLinkRepositoryInstanceIDConditionCall {
c.Call = c.Call.DoAndReturn(f)
return c
}
// List mocks base method.
func (m *MockUserIdentityProviderLinkRepository) List(ctx context.Context, client database.QueryExecutor, condition database.Condition, opts ...database.QueryOption) ([]*domain.UserIdentityProviderLink, error) {
m.ctrl.T.Helper()
varargs := []any{ctx, client, condition}
for _, a := range opts {
varargs = append(varargs, a)
}
ret := m.ctrl.Call(m, "List", varargs...)
ret0, _ := ret[0].([]*domain.UserIdentityProviderLink)
ret1, _ := ret[1].(error)
return ret0, ret1
}
// List indicates an expected call of List.
func (mr *MockUserIdentityProviderLinkRepositoryMockRecorder) List(ctx, client, condition any, opts ...any) *MockUserIdentityProviderLinkRepositoryListCall {
mr.mock.ctrl.T.Helper()
varargs := append([]any{ctx, client, condition}, opts...)
call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "List", reflect.TypeOf((*MockUserIdentityProviderLinkRepository)(nil).List), varargs...)
return &MockUserIdentityProviderLinkRepositoryListCall{Call: call}
}
// MockUserIdentityProviderLinkRepositoryListCall wrap *gomock.Call
type MockUserIdentityProviderLinkRepositoryListCall struct {
*gomock.Call
}
// Return rewrite *gomock.Call.Return
func (c *MockUserIdentityProviderLinkRepositoryListCall) Return(arg0 []*domain.UserIdentityProviderLink, arg1 error) *MockUserIdentityProviderLinkRepositoryListCall {
c.Call = c.Call.Return(arg0, arg1)
return c
}
// Do rewrite *gomock.Call.Do
func (c *MockUserIdentityProviderLinkRepositoryListCall) Do(f func(context.Context, database.QueryExecutor, database.Condition, ...database.QueryOption) ([]*domain.UserIdentityProviderLink, error)) *MockUserIdentityProviderLinkRepositoryListCall {
c.Call = c.Call.Do(f)
return c
}
// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockUserIdentityProviderLinkRepositoryListCall) DoAndReturn(f func(context.Context, database.QueryExecutor, database.Condition, ...database.QueryOption) ([]*domain.UserIdentityProviderLink, error)) *MockUserIdentityProviderLinkRepositoryListCall {
c.Call = c.Call.DoAndReturn(f)
return c
}
// PrimaryKeyColumns mocks base method.
func (m *MockUserIdentityProviderLinkRepository) PrimaryKeyColumns() []database.Column {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "PrimaryKeyColumns")
ret0, _ := ret[0].([]database.Column)
return ret0
}
// PrimaryKeyColumns indicates an expected call of PrimaryKeyColumns.
func (mr *MockUserIdentityProviderLinkRepositoryMockRecorder) PrimaryKeyColumns() *MockUserIdentityProviderLinkRepositoryPrimaryKeyColumnsCall {
mr.mock.ctrl.T.Helper()
call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PrimaryKeyColumns", reflect.TypeOf((*MockUserIdentityProviderLinkRepository)(nil).PrimaryKeyColumns))
return &MockUserIdentityProviderLinkRepositoryPrimaryKeyColumnsCall{Call: call}
}
// MockUserIdentityProviderLinkRepositoryPrimaryKeyColumnsCall wrap *gomock.Call
type MockUserIdentityProviderLinkRepositoryPrimaryKeyColumnsCall struct {
*gomock.Call
}
// Return rewrite *gomock.Call.Return
func (c *MockUserIdentityProviderLinkRepositoryPrimaryKeyColumnsCall) Return(arg0 []database.Column) *MockUserIdentityProviderLinkRepositoryPrimaryKeyColumnsCall {
c.Call = c.Call.Return(arg0)
return c
}
// Do rewrite *gomock.Call.Do
func (c *MockUserIdentityProviderLinkRepositoryPrimaryKeyColumnsCall) Do(f func() []database.Column) *MockUserIdentityProviderLinkRepositoryPrimaryKeyColumnsCall {
c.Call = c.Call.Do(f)
return c
}
// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockUserIdentityProviderLinkRepositoryPrimaryKeyColumnsCall) DoAndReturn(f func() []database.Column) *MockUserIdentityProviderLinkRepositoryPrimaryKeyColumnsCall {
c.Call = c.Call.DoAndReturn(f)
return c
}
// PrimaryKeyCondition mocks base method.
func (m *MockUserIdentityProviderLinkRepository) PrimaryKeyCondition(instanceID, idpID, providedID string) database.Condition {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "PrimaryKeyCondition", instanceID, idpID, providedID)
ret0, _ := ret[0].(database.Condition)
return ret0
}
// PrimaryKeyCondition indicates an expected call of PrimaryKeyCondition.
func (mr *MockUserIdentityProviderLinkRepositoryMockRecorder) PrimaryKeyCondition(instanceID, idpID, providedID any) *MockUserIdentityProviderLinkRepositoryPrimaryKeyConditionCall {
mr.mock.ctrl.T.Helper()
call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PrimaryKeyCondition", reflect.TypeOf((*MockUserIdentityProviderLinkRepository)(nil).PrimaryKeyCondition), instanceID, idpID, providedID)
return &MockUserIdentityProviderLinkRepositoryPrimaryKeyConditionCall{Call: call}
}
// MockUserIdentityProviderLinkRepositoryPrimaryKeyConditionCall wrap *gomock.Call
type MockUserIdentityProviderLinkRepositoryPrimaryKeyConditionCall struct {
*gomock.Call
}
// Return rewrite *gomock.Call.Return
func (c *MockUserIdentityProviderLinkRepositoryPrimaryKeyConditionCall) Return(arg0 database.Condition) *MockUserIdentityProviderLinkRepositoryPrimaryKeyConditionCall {
c.Call = c.Call.Return(arg0)
return c
}
// Do rewrite *gomock.Call.Do
func (c *MockUserIdentityProviderLinkRepositoryPrimaryKeyConditionCall) Do(f func(string, string, string) database.Condition) *MockUserIdentityProviderLinkRepositoryPrimaryKeyConditionCall {
c.Call = c.Call.Do(f)
return c
}
// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockUserIdentityProviderLinkRepositoryPrimaryKeyConditionCall) DoAndReturn(f func(string, string, string) database.Condition) *MockUserIdentityProviderLinkRepositoryPrimaryKeyConditionCall {
c.Call = c.Call.DoAndReturn(f)
return c
}
// ProvidedIDColumn mocks base method.
func (m *MockUserIdentityProviderLinkRepository) ProvidedIDColumn() database.Column {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "ProvidedIDColumn")
ret0, _ := ret[0].(database.Column)
return ret0
}
// ProvidedIDColumn indicates an expected call of ProvidedIDColumn.
func (mr *MockUserIdentityProviderLinkRepositoryMockRecorder) ProvidedIDColumn() *MockUserIdentityProviderLinkRepositoryProvidedIDColumnCall {
mr.mock.ctrl.T.Helper()
call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ProvidedIDColumn", reflect.TypeOf((*MockUserIdentityProviderLinkRepository)(nil).ProvidedIDColumn))
return &MockUserIdentityProviderLinkRepositoryProvidedIDColumnCall{Call: call}
}
// MockUserIdentityProviderLinkRepositoryProvidedIDColumnCall wrap *gomock.Call
type MockUserIdentityProviderLinkRepositoryProvidedIDColumnCall struct {
*gomock.Call
}
// Return rewrite *gomock.Call.Return
func (c *MockUserIdentityProviderLinkRepositoryProvidedIDColumnCall) Return(arg0 database.Column) *MockUserIdentityProviderLinkRepositoryProvidedIDColumnCall {
c.Call = c.Call.Return(arg0)
return c
}
// Do rewrite *gomock.Call.Do
func (c *MockUserIdentityProviderLinkRepositoryProvidedIDColumnCall) Do(f func() database.Column) *MockUserIdentityProviderLinkRepositoryProvidedIDColumnCall {
c.Call = c.Call.Do(f)
return c
}
// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockUserIdentityProviderLinkRepositoryProvidedIDColumnCall) DoAndReturn(f func() database.Column) *MockUserIdentityProviderLinkRepositoryProvidedIDColumnCall {
c.Call = c.Call.DoAndReturn(f)
return c
}
// ProvidedIDCondition mocks base method.
func (m *MockUserIdentityProviderLinkRepository) ProvidedIDCondition(op database.TextOperation, id string) database.Condition {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "ProvidedIDCondition", op, id)
ret0, _ := ret[0].(database.Condition)
return ret0
}
// ProvidedIDCondition indicates an expected call of ProvidedIDCondition.
func (mr *MockUserIdentityProviderLinkRepositoryMockRecorder) ProvidedIDCondition(op, id any) *MockUserIdentityProviderLinkRepositoryProvidedIDConditionCall {
mr.mock.ctrl.T.Helper()
call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ProvidedIDCondition", reflect.TypeOf((*MockUserIdentityProviderLinkRepository)(nil).ProvidedIDCondition), op, id)
return &MockUserIdentityProviderLinkRepositoryProvidedIDConditionCall{Call: call}
}
// MockUserIdentityProviderLinkRepositoryProvidedIDConditionCall wrap *gomock.Call
type MockUserIdentityProviderLinkRepositoryProvidedIDConditionCall struct {
*gomock.Call
}
// Return rewrite *gomock.Call.Return
func (c *MockUserIdentityProviderLinkRepositoryProvidedIDConditionCall) Return(arg0 database.Condition) *MockUserIdentityProviderLinkRepositoryProvidedIDConditionCall {
c.Call = c.Call.Return(arg0)
return c
}
// Do rewrite *gomock.Call.Do
func (c *MockUserIdentityProviderLinkRepositoryProvidedIDConditionCall) Do(f func(database.TextOperation, string) database.Condition) *MockUserIdentityProviderLinkRepositoryProvidedIDConditionCall {
c.Call = c.Call.Do(f)
return c
}
// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockUserIdentityProviderLinkRepositoryProvidedIDConditionCall) DoAndReturn(f func(database.TextOperation, string) database.Condition) *MockUserIdentityProviderLinkRepositoryProvidedIDConditionCall {
c.Call = c.Call.DoAndReturn(f)
return c
}
// ProvidedUsernameColumn mocks base method.
func (m *MockUserIdentityProviderLinkRepository) ProvidedUsernameColumn() database.Column {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "ProvidedUsernameColumn")
ret0, _ := ret[0].(database.Column)
return ret0
}
// ProvidedUsernameColumn indicates an expected call of ProvidedUsernameColumn.
func (mr *MockUserIdentityProviderLinkRepositoryMockRecorder) ProvidedUsernameColumn() *MockUserIdentityProviderLinkRepositoryProvidedUsernameColumnCall {
mr.mock.ctrl.T.Helper()
call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ProvidedUsernameColumn", reflect.TypeOf((*MockUserIdentityProviderLinkRepository)(nil).ProvidedUsernameColumn))
return &MockUserIdentityProviderLinkRepositoryProvidedUsernameColumnCall{Call: call}
}
// MockUserIdentityProviderLinkRepositoryProvidedUsernameColumnCall wrap *gomock.Call
type MockUserIdentityProviderLinkRepositoryProvidedUsernameColumnCall struct {
*gomock.Call
}
// Return rewrite *gomock.Call.Return
func (c *MockUserIdentityProviderLinkRepositoryProvidedUsernameColumnCall) Return(arg0 database.Column) *MockUserIdentityProviderLinkRepositoryProvidedUsernameColumnCall {
c.Call = c.Call.Return(arg0)
return c
}
// Do rewrite *gomock.Call.Do
func (c *MockUserIdentityProviderLinkRepositoryProvidedUsernameColumnCall) Do(f func() database.Column) *MockUserIdentityProviderLinkRepositoryProvidedUsernameColumnCall {
c.Call = c.Call.Do(f)
return c
}
// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockUserIdentityProviderLinkRepositoryProvidedUsernameColumnCall) DoAndReturn(f func() database.Column) *MockUserIdentityProviderLinkRepositoryProvidedUsernameColumnCall {
c.Call = c.Call.DoAndReturn(f)
return c
}
// ProvidedUsernameCondition mocks base method.
func (m *MockUserIdentityProviderLinkRepository) ProvidedUsernameCondition(op database.TextOperation, username string) database.Condition {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "ProvidedUsernameCondition", op, username)
ret0, _ := ret[0].(database.Condition)
return ret0
}
// ProvidedUsernameCondition indicates an expected call of ProvidedUsernameCondition.
func (mr *MockUserIdentityProviderLinkRepositoryMockRecorder) ProvidedUsernameCondition(op, username any) *MockUserIdentityProviderLinkRepositoryProvidedUsernameConditionCall {
mr.mock.ctrl.T.Helper()
call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ProvidedUsernameCondition", reflect.TypeOf((*MockUserIdentityProviderLinkRepository)(nil).ProvidedUsernameCondition), op, username)
return &MockUserIdentityProviderLinkRepositoryProvidedUsernameConditionCall{Call: call}
}
// MockUserIdentityProviderLinkRepositoryProvidedUsernameConditionCall wrap *gomock.Call
type MockUserIdentityProviderLinkRepositoryProvidedUsernameConditionCall struct {
*gomock.Call
}
// Return rewrite *gomock.Call.Return
func (c *MockUserIdentityProviderLinkRepositoryProvidedUsernameConditionCall) Return(arg0 database.Condition) *MockUserIdentityProviderLinkRepositoryProvidedUsernameConditionCall {
c.Call = c.Call.Return(arg0)
return c
}
// Do rewrite *gomock.Call.Do
func (c *MockUserIdentityProviderLinkRepositoryProvidedUsernameConditionCall) Do(f func(database.TextOperation, string) database.Condition) *MockUserIdentityProviderLinkRepositoryProvidedUsernameConditionCall {
c.Call = c.Call.Do(f)
return c
}
// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockUserIdentityProviderLinkRepositoryProvidedUsernameConditionCall) DoAndReturn(f func(database.TextOperation, string) database.Condition) *MockUserIdentityProviderLinkRepositoryProvidedUsernameConditionCall {
c.Call = c.Call.DoAndReturn(f)
return c
}
// SetProvidedUserID mocks base method.
func (m *MockUserIdentityProviderLinkRepository) SetProvidedUserID(providedID string) database.Change {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "SetProvidedUserID", providedID)
ret0, _ := ret[0].(database.Change)
return ret0
}
// SetProvidedUserID indicates an expected call of SetProvidedUserID.
func (mr *MockUserIdentityProviderLinkRepositoryMockRecorder) SetProvidedUserID(providedID any) *MockUserIdentityProviderLinkRepositorySetProvidedUserIDCall {
mr.mock.ctrl.T.Helper()
call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetProvidedUserID", reflect.TypeOf((*MockUserIdentityProviderLinkRepository)(nil).SetProvidedUserID), providedID)
return &MockUserIdentityProviderLinkRepositorySetProvidedUserIDCall{Call: call}
}
// MockUserIdentityProviderLinkRepositorySetProvidedUserIDCall wrap *gomock.Call
type MockUserIdentityProviderLinkRepositorySetProvidedUserIDCall struct {
*gomock.Call
}
// Return rewrite *gomock.Call.Return
func (c *MockUserIdentityProviderLinkRepositorySetProvidedUserIDCall) Return(arg0 database.Change) *MockUserIdentityProviderLinkRepositorySetProvidedUserIDCall {
c.Call = c.Call.Return(arg0)
return c
}
// Do rewrite *gomock.Call.Do
func (c *MockUserIdentityProviderLinkRepositorySetProvidedUserIDCall) Do(f func(string) database.Change) *MockUserIdentityProviderLinkRepositorySetProvidedUserIDCall {
c.Call = c.Call.Do(f)
return c
}
// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockUserIdentityProviderLinkRepositorySetProvidedUserIDCall) DoAndReturn(f func(string) database.Change) *MockUserIdentityProviderLinkRepositorySetProvidedUserIDCall {
c.Call = c.Call.DoAndReturn(f)
return c
}
// SetProvidedUsername mocks base method.
func (m *MockUserIdentityProviderLinkRepository) SetProvidedUsername(username string) database.Change {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "SetProvidedUsername", username)
ret0, _ := ret[0].(database.Change)
return ret0
}
// SetProvidedUsername indicates an expected call of SetProvidedUsername.
func (mr *MockUserIdentityProviderLinkRepositoryMockRecorder) SetProvidedUsername(username any) *MockUserIdentityProviderLinkRepositorySetProvidedUsernameCall {
mr.mock.ctrl.T.Helper()
call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetProvidedUsername", reflect.TypeOf((*MockUserIdentityProviderLinkRepository)(nil).SetProvidedUsername), username)
return &MockUserIdentityProviderLinkRepositorySetProvidedUsernameCall{Call: call}
}
// MockUserIdentityProviderLinkRepositorySetProvidedUsernameCall wrap *gomock.Call
type MockUserIdentityProviderLinkRepositorySetProvidedUsernameCall struct {
*gomock.Call
}
// Return rewrite *gomock.Call.Return
func (c *MockUserIdentityProviderLinkRepositorySetProvidedUsernameCall) Return(arg0 database.Change) *MockUserIdentityProviderLinkRepositorySetProvidedUsernameCall {
c.Call = c.Call.Return(arg0)
return c
}
// Do rewrite *gomock.Call.Do
func (c *MockUserIdentityProviderLinkRepositorySetProvidedUsernameCall) Do(f func(string) database.Change) *MockUserIdentityProviderLinkRepositorySetProvidedUsernameCall {
c.Call = c.Call.Do(f)
return c
}
// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockUserIdentityProviderLinkRepositorySetProvidedUsernameCall) DoAndReturn(f func(string) database.Change) *MockUserIdentityProviderLinkRepositorySetProvidedUsernameCall {
c.Call = c.Call.DoAndReturn(f)
return c
}
// SetUpdatedAt mocks base method.
func (m *MockUserIdentityProviderLinkRepository) SetUpdatedAt(updatedAt time.Time) database.Change {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "SetUpdatedAt", updatedAt)
ret0, _ := ret[0].(database.Change)
return ret0
}
// SetUpdatedAt indicates an expected call of SetUpdatedAt.
func (mr *MockUserIdentityProviderLinkRepositoryMockRecorder) SetUpdatedAt(updatedAt any) *MockUserIdentityProviderLinkRepositorySetUpdatedAtCall {
mr.mock.ctrl.T.Helper()
call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetUpdatedAt", reflect.TypeOf((*MockUserIdentityProviderLinkRepository)(nil).SetUpdatedAt), updatedAt)
return &MockUserIdentityProviderLinkRepositorySetUpdatedAtCall{Call: call}
}
// MockUserIdentityProviderLinkRepositorySetUpdatedAtCall wrap *gomock.Call
type MockUserIdentityProviderLinkRepositorySetUpdatedAtCall struct {
*gomock.Call
}
// Return rewrite *gomock.Call.Return
func (c *MockUserIdentityProviderLinkRepositorySetUpdatedAtCall) Return(arg0 database.Change) *MockUserIdentityProviderLinkRepositorySetUpdatedAtCall {
c.Call = c.Call.Return(arg0)
return c
}
// Do rewrite *gomock.Call.Do
func (c *MockUserIdentityProviderLinkRepositorySetUpdatedAtCall) Do(f func(time.Time) database.Change) *MockUserIdentityProviderLinkRepositorySetUpdatedAtCall {
c.Call = c.Call.Do(f)
return c
}
// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockUserIdentityProviderLinkRepositorySetUpdatedAtCall) DoAndReturn(f func(time.Time) database.Change) *MockUserIdentityProviderLinkRepositorySetUpdatedAtCall {
c.Call = c.Call.DoAndReturn(f)
return c
}
// Update mocks base method.
func (m *MockUserIdentityProviderLinkRepository) Update(ctx context.Context, client database.QueryExecutor, condition database.Condition, changes ...database.Change) (int64, error) {
m.ctrl.T.Helper()
varargs := []any{ctx, client, condition}
for _, a := range changes {
varargs = append(varargs, a)
}
ret := m.ctrl.Call(m, "Update", varargs...)
ret0, _ := ret[0].(int64)
ret1, _ := ret[1].(error)
return ret0, ret1
}
// Update indicates an expected call of Update.
func (mr *MockUserIdentityProviderLinkRepositoryMockRecorder) Update(ctx, client, condition any, changes ...any) *MockUserIdentityProviderLinkRepositoryUpdateCall {
mr.mock.ctrl.T.Helper()
varargs := append([]any{ctx, client, condition}, changes...)
call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Update", reflect.TypeOf((*MockUserIdentityProviderLinkRepository)(nil).Update), varargs...)
return &MockUserIdentityProviderLinkRepositoryUpdateCall{Call: call}
}
// MockUserIdentityProviderLinkRepositoryUpdateCall wrap *gomock.Call
type MockUserIdentityProviderLinkRepositoryUpdateCall struct {
*gomock.Call
}
// Return rewrite *gomock.Call.Return
func (c *MockUserIdentityProviderLinkRepositoryUpdateCall) Return(arg0 int64, arg1 error) *MockUserIdentityProviderLinkRepositoryUpdateCall {
c.Call = c.Call.Return(arg0, arg1)
return c
}
// Do rewrite *gomock.Call.Do
func (c *MockUserIdentityProviderLinkRepositoryUpdateCall) Do(f func(context.Context, database.QueryExecutor, database.Condition, ...database.Change) (int64, error)) *MockUserIdentityProviderLinkRepositoryUpdateCall {
c.Call = c.Call.Do(f)
return c
}
// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockUserIdentityProviderLinkRepositoryUpdateCall) DoAndReturn(f func(context.Context, database.QueryExecutor, database.Condition, ...database.Change) (int64, error)) *MockUserIdentityProviderLinkRepositoryUpdateCall {
c.Call = c.Call.DoAndReturn(f)
return c
}
// UpdatedAtColumn mocks base method.
func (m *MockUserIdentityProviderLinkRepository) UpdatedAtColumn() database.Column {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "UpdatedAtColumn")
ret0, _ := ret[0].(database.Column)
return ret0
}
// UpdatedAtColumn indicates an expected call of UpdatedAtColumn.
func (mr *MockUserIdentityProviderLinkRepositoryMockRecorder) UpdatedAtColumn() *MockUserIdentityProviderLinkRepositoryUpdatedAtColumnCall {
mr.mock.ctrl.T.Helper()
call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdatedAtColumn", reflect.TypeOf((*MockUserIdentityProviderLinkRepository)(nil).UpdatedAtColumn))
return &MockUserIdentityProviderLinkRepositoryUpdatedAtColumnCall{Call: call}
}
// MockUserIdentityProviderLinkRepositoryUpdatedAtColumnCall wrap *gomock.Call
type MockUserIdentityProviderLinkRepositoryUpdatedAtColumnCall struct {
*gomock.Call
}
// Return rewrite *gomock.Call.Return
func (c *MockUserIdentityProviderLinkRepositoryUpdatedAtColumnCall) Return(arg0 database.Column) *MockUserIdentityProviderLinkRepositoryUpdatedAtColumnCall {
c.Call = c.Call.Return(arg0)
return c
}
// Do rewrite *gomock.Call.Do
func (c *MockUserIdentityProviderLinkRepositoryUpdatedAtColumnCall) Do(f func() database.Column) *MockUserIdentityProviderLinkRepositoryUpdatedAtColumnCall {
c.Call = c.Call.Do(f)
return c
}
// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockUserIdentityProviderLinkRepositoryUpdatedAtColumnCall) DoAndReturn(f func() database.Column) *MockUserIdentityProviderLinkRepositoryUpdatedAtColumnCall {
c.Call = c.Call.DoAndReturn(f)
return c
}
// UserIDColumn mocks base method.
func (m *MockUserIdentityProviderLinkRepository) UserIDColumn() database.Column {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "UserIDColumn")
ret0, _ := ret[0].(database.Column)
return ret0
}
// UserIDColumn indicates an expected call of UserIDColumn.
func (mr *MockUserIdentityProviderLinkRepositoryMockRecorder) UserIDColumn() *MockUserIdentityProviderLinkRepositoryUserIDColumnCall {
mr.mock.ctrl.T.Helper()
call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UserIDColumn", reflect.TypeOf((*MockUserIdentityProviderLinkRepository)(nil).UserIDColumn))
return &MockUserIdentityProviderLinkRepositoryUserIDColumnCall{Call: call}
}
// MockUserIdentityProviderLinkRepositoryUserIDColumnCall wrap *gomock.Call
type MockUserIdentityProviderLinkRepositoryUserIDColumnCall struct {
*gomock.Call
}
// Return rewrite *gomock.Call.Return
func (c *MockUserIdentityProviderLinkRepositoryUserIDColumnCall) Return(arg0 database.Column) *MockUserIdentityProviderLinkRepositoryUserIDColumnCall {
c.Call = c.Call.Return(arg0)
return c
}
// Do rewrite *gomock.Call.Do
func (c *MockUserIdentityProviderLinkRepositoryUserIDColumnCall) Do(f func() database.Column) *MockUserIdentityProviderLinkRepositoryUserIDColumnCall {
c.Call = c.Call.Do(f)
return c
}
// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockUserIdentityProviderLinkRepositoryUserIDColumnCall) DoAndReturn(f func() database.Column) *MockUserIdentityProviderLinkRepositoryUserIDColumnCall {
c.Call = c.Call.DoAndReturn(f)
return c
}
// UserIDCondition mocks base method.
func (m *MockUserIdentityProviderLinkRepository) UserIDCondition(op database.TextOperation, id string) database.Condition {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "UserIDCondition", op, id)
ret0, _ := ret[0].(database.Condition)
return ret0
}
// UserIDCondition indicates an expected call of UserIDCondition.
func (mr *MockUserIdentityProviderLinkRepositoryMockRecorder) UserIDCondition(op, id any) *MockUserIdentityProviderLinkRepositoryUserIDConditionCall {
mr.mock.ctrl.T.Helper()
call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UserIDCondition", reflect.TypeOf((*MockUserIdentityProviderLinkRepository)(nil).UserIDCondition), op, id)
return &MockUserIdentityProviderLinkRepositoryUserIDConditionCall{Call: call}
}
// MockUserIdentityProviderLinkRepositoryUserIDConditionCall wrap *gomock.Call
type MockUserIdentityProviderLinkRepositoryUserIDConditionCall struct {
*gomock.Call
}
// Return rewrite *gomock.Call.Return
func (c *MockUserIdentityProviderLinkRepositoryUserIDConditionCall) Return(arg0 database.Condition) *MockUserIdentityProviderLinkRepositoryUserIDConditionCall {
c.Call = c.Call.Return(arg0)
return c
}
// Do rewrite *gomock.Call.Do
func (c *MockUserIdentityProviderLinkRepositoryUserIDConditionCall) Do(f func(database.TextOperation, string) database.Condition) *MockUserIdentityProviderLinkRepositoryUserIDConditionCall {
c.Call = c.Call.Do(f)
return c
}
// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockUserIdentityProviderLinkRepositoryUserIDConditionCall) DoAndReturn(f func(database.TextOperation, string) database.Condition) *MockUserIdentityProviderLinkRepositoryUserIDConditionCall {
c.Call = c.Call.DoAndReturn(f)
return c
}
backend/v3/domain/passkeytype_enumer.go
+50 -1
View File
@@ -1,8 +1,10 @@
// Code generated by "enumer -type PasskeyType -transform lower -trimprefix PasskeyType"; DO NOT EDIT.
// Code generated by "enumer -type PasskeyType -transform lower -trimprefix PasskeyType -json -sql"; DO NOT EDIT.
package domain
import (
"database/sql/driver"
"encoding/json"
"fmt"
"strings"
)
@@ -80,3 +82,50 @@ func (i PasskeyType) IsAPasskeyType() bool {
}
return false
}
// MarshalJSON implements the json.Marshaler interface for PasskeyType
func (i PasskeyType) MarshalJSON() ([]byte, error) {
return json.Marshal(i.String())
}
// UnmarshalJSON implements the json.Unmarshaler interface for PasskeyType
func (i *PasskeyType) UnmarshalJSON(data []byte) error {
var s string
if err := json.Unmarshal(data, &s); err != nil {
return fmt.Errorf("PasskeyType should be a string, got %s", data)
}
var err error
*i, err = PasskeyTypeString(s)
return err
}
func (i PasskeyType) Value() (driver.Value, error) {
return i.String(), nil
}
func (i *PasskeyType) Scan(value interface{}) error {
if value == nil {
return nil
}
var str string
switch v := value.(type) {
case []byte:
str = string(v)
case string:
str = v
case fmt.Stringer:
str = v.String()
default:
return fmt.Errorf("invalid value of PasskeyType: %[1]T(%[1]v)", value)
}
val, err := PasskeyTypeString(str)
if err != nil {
return err
}
*i = val
return nil
}
backend/v3/domain/personalaccesstokentype_enumer.go
-82
View File
@@ -1,82 +0,0 @@
// Code generated by "enumer -type PersonalAccessTokenType -transform lower -trimprefix PersonalAccessTokenType"; DO NOT EDIT.
package domain
import (
"fmt"
"strings"
)
const _PersonalAccessTokenTypeName = "unspecifiedbearerjwt"
var _PersonalAccessTokenTypeIndex = [...]uint8{0, 11, 17, 20}
const _PersonalAccessTokenTypeLowerName = "unspecifiedbearerjwt"
func (i PersonalAccessTokenType) String() string {
if i >= PersonalAccessTokenType(len(_PersonalAccessTokenTypeIndex)-1) {
return fmt.Sprintf("PersonalAccessTokenType(%d)", i)
}
return _PersonalAccessTokenTypeName[_PersonalAccessTokenTypeIndex[i]:_PersonalAccessTokenTypeIndex[i+1]]
}
// An "invalid array index" compiler error signifies that the constant values have changed.
// Re-run the stringer command to generate them again.
func _PersonalAccessTokenTypeNoOp() {
var x [1]struct{}
_ = x[PersonalAccessTokenTypeUnspecified-(0)]
_ = x[PersonalAccessTokenTypeBearer-(1)]
_ = x[PersonalAccessTokenTypeJWT-(2)]
}
var _PersonalAccessTokenTypeValues = []PersonalAccessTokenType{PersonalAccessTokenTypeUnspecified, PersonalAccessTokenTypeBearer, PersonalAccessTokenTypeJWT}
var _PersonalAccessTokenTypeNameToValueMap = map[string]PersonalAccessTokenType{
_PersonalAccessTokenTypeName[0:11]: PersonalAccessTokenTypeUnspecified,
_PersonalAccessTokenTypeLowerName[0:11]: PersonalAccessTokenTypeUnspecified,
_PersonalAccessTokenTypeName[11:17]: PersonalAccessTokenTypeBearer,
_PersonalAccessTokenTypeLowerName[11:17]: PersonalAccessTokenTypeBearer,
_PersonalAccessTokenTypeName[17:20]: PersonalAccessTokenTypeJWT,
_PersonalAccessTokenTypeLowerName[17:20]: PersonalAccessTokenTypeJWT,
}
var _PersonalAccessTokenTypeNames = []string{
_PersonalAccessTokenTypeName[0:11],
_PersonalAccessTokenTypeName[11:17],
_PersonalAccessTokenTypeName[17:20],
}
// PersonalAccessTokenTypeString retrieves an enum value from the enum constants string name.
// Throws an error if the param is not part of the enum.
func PersonalAccessTokenTypeString(s string) (PersonalAccessTokenType, error) {
if val, ok := _PersonalAccessTokenTypeNameToValueMap[s]; ok {
return val, nil
}
if val, ok := _PersonalAccessTokenTypeNameToValueMap[strings.ToLower(s)]; ok {
return val, nil
}
return 0, fmt.Errorf("%s does not belong to PersonalAccessTokenType values", s)
}
// PersonalAccessTokenTypeValues returns all values of the enum
func PersonalAccessTokenTypeValues() []PersonalAccessTokenType {
return _PersonalAccessTokenTypeValues
}
// PersonalAccessTokenTypeStrings returns a slice of all String values of the enum
func PersonalAccessTokenTypeStrings() []string {
strs := make([]string, len(_PersonalAccessTokenTypeNames))
copy(strs, _PersonalAccessTokenTypeNames)
return strs
}
// IsAPersonalAccessTokenType returns "true" if the value is listed in the enum definition. "false" otherwise
func (i PersonalAccessTokenType) IsAPersonalAccessTokenType() bool {
for _, v := range _PersonalAccessTokenTypeValues {
if i == v {
return true
}
}
return false
}
backend/v3/domain/user.go
+108 -93
View File
@@ -4,6 +4,8 @@ import (
"time"
"golang.org/x/text/language"
"github.com/zitadel/zitadel/internal/crypto"
)
type User struct {
@@ -15,48 +17,50 @@ type User struct {
CreatedAt time.Time `json:"createdAt,omitzero" db:"created_at"`
UpdatedAt time.Time `json:"updatedAt,omitzero" db:"updated_at"`
Machine *MachineUser `json:"machine,omitempty" db:"machine"`
Human *HumanUser `json:"human,omitempty" db:"human"`
Metadata []*UserMetadata `json:"metadata,omitempty" db:"metadata"`
Machine *MachineUser `json:"machine,omitempty" db:"-"`
Human *HumanUser `json:"human,omitempty" db:"-"`
Metadata []*Metadata `json:"metadata,omitempty" db:"metadata"`
}
type MachineUser struct {
Name string `json:"name,omitempty" db:"name"`
Description string `json:"description,omitempty" db:"description"`
Secret string `json:"secret,omitempty" db:"secret"`
AccessTokenType PersonalAccessTokenType `json:"access_token_type,omitempty" db:"access_token_type"`
Name string `json:"name,omitempty" db:"-"`
Description string `json:"description,omitempty" db:"-"`
Secret string `json:"secret,omitempty" db:"-"`
AccessTokenType AccessTokenType `json:"accessTokenType,omitempty" db:"-"`
PATs []*PersonalAccessToken `json:"pats,omitempty" db:"pats"`
Keys []*MachineKey `json:"keys,omitempty" db:"keys"`
PATs []*PersonalAccessToken `json:"pats,omitempty" db:"-"`
Keys []*MachineKey `json:"keys,omitempty" db:"-"`
}
type HumanUser struct {
FirstName string `json:"firstName,omitempty" db:"first_name"`
LastName string `json:"lastName,omitempty" db:"last_name"`
Nickname string `json:"nickname,omitempty" db:"nickname"`
DisplayName string `json:"displayName,omitempty" db:"display_name"`
PreferredLanguage language.Tag `json:"preferredLanguage,omitzero" db:"preferred_language"`
Gender HumanGender `json:"gender,omitempty" db:"gender"`
AvatarKey string `json:"avatarKey,omitempty" db:"avatar_key"`
FirstName string `json:"firstName,omitempty" db:"-"`
LastName string `json:"lastName,omitempty" db:"-"`
Nickname string `json:"nickname,omitempty" db:"-"`
DisplayName string `json:"displayName,omitempty" db:"-"`
PreferredLanguage language.Tag `json:"preferredLanguage,omitzero" db:"-"`
Gender HumanGender `json:"gender,omitempty" db:"-"`
AvatarKey string `json:"avatarKey,omitempty" db:"-"`
MultifactorInitializationSkippedAt time.Time `json:"multifactorInitializationSkippedAt,omitzero" db:"multifactor_initialization_skipped_at"`
MultifactorInitializationSkippedAt time.Time `json:"multifactorInitializationSkippedAt,omitzero" db:"-"`
Email HumanEmail `json:"email,omitzero" db:"email"`
Phone *HumanPhone `json:"phone,omitempty" db:"phone"`
Passkeys []*Passkey `json:"passkeys,omitempty" db:"passkeys"`
Password HumanPassword `json:"password,omitzero" db:"password"`
TOTP HumanTOTP `json:"totp,omitzero" db:"totp"`
Email HumanEmail `json:"email,omitzero" db:"-"`
Phone *HumanPhone `json:"phone,omitempty" db:"-"`
Passkeys []*Passkey `json:"passkeys,omitempty" db:"-"`
Password HumanPassword `json:"password,omitzero" db:"-"`
TOTP *HumanTOTP `json:"totp,omitempty" db:"-"`
IdentityProviderLinks []*IdentityProviderLink `json:"identityProviderLinks,omitempty" db:"identity_provider_links"`
IdentityProviderLinks []*IdentityProviderLink `json:"identityProviderLinks,omitempty" db:"-"`
Invite *HumanInvite `json:"invite,omitempty" db:"-"`
// Verifications are used if the Login does something on behalf of the user that requires verification
// e.g. starting passkey registration
Verifications []*Verification `db:"verifications" json:"verifications,omitempty"`
Verifications []*Verification `json:"verifications,omitempty" db:"-"`
}
type UserMetadata struct {
Metadata
UserID string `json:"userId,omitempty" db:"user_id"`
UserID string `json:"userId,omitempty" db:"-"`
}
//go:generate enumer -type UserState -transform lower -trimprefix UserState -sql
@@ -83,81 +87,84 @@ const (
)
type HumanPassword struct {
// Password is the hashed password
Password string `json:"-" db:"password"`
// Hash is the hashed password
Hash string `json:"hash" db:"-"`
// IsChangeRequired indicates if the user must change their password
IsChangeRequired bool `json:"isChangeRequired,omitempty" db:"is_change_required"`
// VerifiedAt is the time when the current password was verified
VerifiedAt time.Time `json:"verifiedAt,omitzero" db:"verified_at"`
// Unverified is the verification data for setting a new password
IsChangeRequired bool `json:"isChangeRequired,omitempty" db:"-"`
// ChangedAt is the time when the current password was last updated
ChangedAt time.Time `json:"changedAt,omitzero" db:"-"`
// PendingVerification is the verification data for setting a new password
// If nil, no password change is in progress
Unverified *Verification `json:"-"`
PendingVerification *Verification `json:"pendingVerification,omitempty" db:"-"`
// LastSuccessfullyCheckedAt is the time when the password was last successfully checked
LastSuccessfullyCheckedAt *time.Time `json:"lastSuccessfullyCheckedAt,omitzero" db:"-"`
// FailedAttempts is the number of consecutive failed password attempts
// It is reset to 0 on successful verification
FailedAttempts uint8 `json:"failedAttempts,omitempty" db:"failed_attempts"`
FailedAttempts uint8 `json:"failedAttempts,omitempty" db:"-"`
}
type HumanEmail struct {
Address string `json:"address" db:"email"`
VerifiedAt time.Time `json:"verifiedAt,omitzero" db:"verified_at"`
OTP OTP `json:"-"`
// Unverified is the verification data for setting a new email
Address string `json:"address" db:"-"`
UnverifiedAddress string `json:"unverifiedAddress,omitempty" db:"-"`
VerifiedAt time.Time `json:"verifiedAt,omitzero" db:"-"`
OTP OTP `json:"otp" db:"-"`
// PendingVerification is the verification data for UnverifiedAddress
// If nil, no email change is in progress
Unverified *Verification `json:"-"`
PendingVerification *Verification `json:"pendingVerification,omitempty" db:"-"`
}
type HumanPhone struct {
Number string `json:"number" db:"phone"`
VerifiedAt time.Time `json:"verifiedAt,omitzero" db:"verified_at"`
OTP OTP `json:"-"`
// Unverified is the verification data for setting a new phone number
Number string `json:"number" db:"-"`
UnverifiedNumber string `json:"unverifiedNumber,omitempty" db:"-"`
VerifiedAt time.Time `json:"verifiedAt,omitzero" db:"-"`
OTP OTP `json:"otp,omitzero" db:"-"`
// PendingVerification is the verification data for setting a new phone number
// If nil, no phone change is in progress
Unverified *Verification `json:"-"`
PendingVerification *Verification `json:"pendingVerification,omitempty" db:"-"`
}
type HumanTOTP struct {
VerifiedAt time.Time `json:"verifiedAt,omitzero" db:"verified_at"`
VerifiedAt time.Time `json:"verifiedAt,omitzero" db:"-"`
Secret *crypto.CryptoValue `json:"secret,omitempty" db:"-"`
// LastSuccessfullyCheckedAt is the time when the TOTP was last successfully checked
LastSuccessfullyCheckedAt *time.Time `json:"lastSuccessfullyCheckedAt,omitzero" db:"-"`
LastSuccessfullyCheckedAt time.Time `json:"lastSuccessfullyCheckedAt,omitzero" db:"last_successfully_checked_at"`
// Check is the verified secret
Check *Check `json:"-"`
// Unverified is the unverified secret
Unverified *Verification `json:"-"`
// FailedAttempts is the number of consecutive failed password attempts
// It is reset to 0 on successful verification
FailedAttempts uint8 `json:"failedAttempts,omitempty" db:"-"`
}
type OTP struct {
EnabledAt time.Time `json:"enabledAt,omitzero" db:"enabled_at"`
LastSuccessfullyCheckedAt time.Time `json:"lastSuccessfullyCheckedAt,omitzero" db:"last_successfully_checked_at"`
// Check is the currently active OTP check
// If nil, no OTP check is active
Check *Check `json:"-"`
EnabledAt time.Time `json:"enabledAt,omitzero" db:"-"`
// LastSuccessfullyCheckedAt is the time when the OTP was last successfully checked
LastSuccessfullyCheckedAt *time.Time `json:"lastSuccessfullyCheckedAt,omitzero" db:"-"`
// FailedAttempts is the number of consecutive failed password attempts
// It is reset to 0 on successful verification
FailedAttempts uint8 `json:"failedAttempts,omitempty" db:"-"`
}
type PersonalAccessToken struct {
ID string `json:"id" db:"id"`
CreatedAt time.Time `json:"createdAt,omitzero" db:"created_at"`
ExpiresAt time.Time `json:"expiresAt,omitzero" db:"expires_at"`
Type PersonalAccessTokenType `json:"type" db:"type"`
PublicKey string `json:"-" db:"public_key"`
Scopes []string `json:"scopes" db:"scopes"`
ID string `json:"id" db:"-"`
CreatedAt time.Time `json:"createdAt,omitzero" db:"-"`
ExpiresAt time.Time `json:"expiresAt,omitzero" db:"-"`
Scopes []string `json:"scopes" db:"-"`
}
//go:generate enumer -type PersonalAccessTokenType -transform lower -trimprefix PersonalAccessTokenType
type PersonalAccessTokenType uint8
//go:generate enumer -type AccessTokenType -transform lower -trimprefix AccessTokenType
type AccessTokenType uint8
const (
PersonalAccessTokenTypeUnspecified PersonalAccessTokenType = iota
PersonalAccessTokenTypeBearer
PersonalAccessTokenTypeJWT
AccessTokenTypeUnspecified AccessTokenType = iota
AccessTokenTypeBearer
AccessTokenTypeJWT
)
type MachineKey struct {
ID string `json:"id" db:"id"`
PublicKey []byte `json:"-" db:"public_key"`
CreatedAt time.Time `json:"createdAt,omitzero" db:"created_at"`
ExpiresAt time.Time `json:"expiresAt,omitzero" db:"expires_at"`
Type MachineKeyType `json:"type" db:"type"`
ID string `json:"id" db:"-"`
PublicKey []byte `json:"publicKey" db:"-"`
CreatedAt time.Time `json:"createdAt,omitzero" db:"-"`
ExpiresAt time.Time `json:"expiresAt,omitzero" db:"-"`
Type MachineKeyType `json:"type" db:"-"`
}
//go:generate enumer -type MachineKeyType -transform lower -trimprefix MachineKeyType
@@ -165,35 +172,34 @@ type MachineKey struct {
type MachineKeyType uint8
const (
MachineKeyTypeUnspecified MachineKeyType = iota
MachineKeyTypeNone MachineKeyType = iota
MachineKeyTypeJSON
MachineKeyTypeNone
)
type Passkey struct {
ID string `json:"id" db:"id"`
KeyID []byte `json:"-" db:"key_id"`
Name string `json:"name" db:"name"`
SignCount uint32 `json:"-" db:"sign_count"`
PublicKey []byte `json:"-" db:"public_key"`
AttestationType string `json:"attestationType" db:"attestation_type"`
AuthenticatorAttestationGUID []byte `json:"aaGuid" db:"authenticator_attestation_guid"`
Type PasskeyType `json:"type" db:"type"`
ID string `json:"id" db:"-"`
KeyID []byte `json:"keyId" db:"-"`
Name string `json:"name" db:"-"`
SignCount uint32 `json:"signCount" db:"-"`
PublicKey []byte `json:"publicKey" db:"-"`
AttestationType string `json:"attestationType" db:"-"`
AuthenticatorAttestationGUID []byte `json:"aaGuid" db:"-"`
Type PasskeyType `json:"type" db:"-"`
CreatedAt time.Time `json:"createdAt,omitzero" db:"created_at"`
UpdatedAt time.Time `json:"updatedAt,omitzero" db:"updated_at"`
VerifiedAt time.Time `json:"verifiedAt,omitzero" db:"verified_at"`
CreatedAt time.Time `json:"createdAt,omitzero" db:"-"`
UpdatedAt time.Time `json:"updatedAt,omitzero" db:"-"`
VerifiedAt time.Time `json:"verifiedAt,omitzero" db:"-"`
// Challenge is used during device registration
Challenge []byte `json:"-" db:"challenge"`
Challenge []byte `json:"challenge" db:"-"`
// RelyingPartyID is used during device registration
RelyingPartyID string `json:"-" db:"relying_party_id"`
RelyingPartyID string `json:"rpId" db:"-"`
// Initialization is used during user registration
Initialization *Verification `json:"-" db:"initialization"`
Initialization *Verification `json:"-" db:"-"`
}
//go:generate enumer -type PasskeyType -transform lower -trimprefix PasskeyType
//go:generate enumer -type PasskeyType -transform lower -trimprefix PasskeyType -json -sql
type PasskeyType uint8
@@ -204,12 +210,12 @@ const (
)
type IdentityProviderLink struct {
ProviderID string `json:"providerId" db:"provider_id"`
ProvidedUserID string `json:"providedUserId" db:"provided_user_id"`
ProvidedUsername string `json:"providedUsername" db:"provided_username"`
ProviderID string `json:"providerId" db:"-"`
ProvidedUserID string `json:"providedUserId" db:"-"`
ProvidedUsername string `json:"providedUsername" db:"-"`
CreatedAt time.Time `json:"createdAt,omitzero" db:"created_at"`
UpdatedAt time.Time `json:"updatedAt,omitzero" db:"updated_at"`
CreatedAt time.Time `json:"createdAt,omitzero" db:"-"`
UpdatedAt time.Time `json:"updatedAt,omitzero" db:"-"`
}
//go:generate enumer -type UserType -transform lower -trimprefix UserType
@@ -221,3 +227,12 @@ const (
UserTypeHuman
UserTypeMachine
)
type HumanInvite struct {
AcceptedAt time.Time `json:"acceptedAt,omitzero" db:"-"`
// PendingVerification is the verification data for UnverifiedAddress
// If nil, no email change is in progress
PendingVerification *Verification `json:"pendingVerification,omitempty" db:"-"`
// FailedAttempts is the number of consecutive failed invite attempts
FailedAttempts uint8 `json:"failedAttempts,omitempty" db:"-"`
}
backend/v3/domain/user_identity_provider_link.go
+60
View File
@@ -0,0 +1,60 @@
package domain
import (
"context"
"time"
"github.com/zitadel/zitadel/backend/v3/storage/database"
)
type UserIdentityProviderLink struct {
InstanceID string `json:"instanceID" db:"instance_id"`
UserID string `json:"userID" db:"user_id"`
IdentityProviderID string `json:"identityProviderID" db:"identity_provider_id"`
ProvidedID string `json:"providedID" db:"provided_id"`
ProvidedUsername string `json:"providedUsername" db:"provided_username"`
CreatedAt time.Time `json:"createdAt,omitempty" db:"created_at"`
UpdatedAt time.Time `json:"updatedAt,omitempty" db:"updated_at"`
}
//go:generate mockgen -typed -package domainmock -destination ./mock/user_identity_provider_link.mock.go . UserIdentityProviderLinkRepository
type UserIdentityProviderLinkRepository interface {
Repository
userIdentityProviderLinkColumns
userIdentityProviderLinkConditions
userIdentityProviderLinkChanges
Get(ctx context.Context, client database.QueryExecutor, condition database.Condition, opts ...database.QueryOption) (*UserIdentityProviderLink, error)
List(ctx context.Context, client database.QueryExecutor, condition database.Condition, opts ...database.QueryOption) ([]*UserIdentityProviderLink, error)
Create(ctx context.Context, client database.QueryExecutor, link *UserIdentityProviderLink) error
Update(ctx context.Context, client database.QueryExecutor, condition database.Condition, changes ...database.Change) (int64, error)
Delete(ctx context.Context, client database.QueryExecutor, condition database.Condition) (int64, error)
}
type userIdentityProviderLinkColumns interface {
InstanceIDColumn() database.Column
UserIDColumn() database.Column
IdentityProviderIDColumn() database.Column
ProvidedIDColumn() database.Column
ProvidedUsernameColumn() database.Column
CreatedAtColumn() database.Column
UpdatedAtColumn() database.Column
}
type userIdentityProviderLinkConditions interface {
PrimaryKeyCondition(instanceID, idpID, providedID string) database.Condition
InstanceIDCondition(op database.TextOperation, id string) database.Condition
UserIDCondition(op database.TextOperation, id string) database.Condition
IdentityProviderIDCondition(op database.TextOperation, id string) database.Condition
ProvidedIDCondition(op database.TextOperation, id string) database.Condition
ProvidedUsernameCondition(op database.TextOperation, username string) database.Condition
}
type userIdentityProviderLinkChanges interface {
SetProvidedUsername(username string) database.Change
SetUpdatedAt(updatedAt time.Time) database.Change
SetProvidedUserID(providedID string) database.Change
}
backend/v3/domain/user_repo.go
+135 -76
View File
@@ -7,6 +7,7 @@ import (
"golang.org/x/text/language"
"github.com/zitadel/zitadel/backend/v3/storage/database"
"github.com/zitadel/zitadel/internal/crypto"
)
//go:generate mockgen -typed -package domainmock -destination ./mock/user.mock.go . UserRepository
@@ -22,13 +23,6 @@ type UserRepository interface {
Human() HumanUserRepository
Machine() MachineUserRepository
LoadMetadata() UserRepository
LoadPasskeys() UserRepository
LoadIdentityProviderLinks() UserRepository
LoadVerifications() UserRepository
LoadPATs() UserRepository
LoadKeys() UserRepository
userConditions
userChanges
userColumns
@@ -37,18 +31,18 @@ type UserRepository interface {
type userConditions interface {
PrimaryKeyCondition(instanceID, userID string) database.Condition
InstanceIDCondition(instanceID string) database.Condition
OrgIDCondition(orgID string) database.Condition
OrganizationIDCondition(orgID string) database.Condition
IDCondition(userID string) database.Condition
UsernameCondition(op database.TextOperation, username string) database.Condition
StateCondition(state UserState) database.Condition
TypeCondition(userType UserType) database.Condition
LoginNameCondition(op database.TextOperation, loginName string) database.Condition
userMetadataConditions
ExistsMetadata(condition database.Condition) database.Condition
MetadataConditions() UserMetadataConditions
}
type userMetadataConditions interface {
ExistsMetadata(condition database.Condition) database.Condition
type UserMetadataConditions interface {
MetadataKeyCondition(op database.TextOperation, key string) database.Condition
MetadataValueCondition(op database.BytesOperation, value []byte) database.Condition
}
@@ -62,8 +56,8 @@ type userChanges interface {
// SetUpdatedAt sets the updated at field
// This is used to replay events
SetUpdatedAt(updatedAt time.Time) database.Change
// AddMetadata adds metadata for the user
AddMetadata(metadata ...*Metadata) database.Change
// SetMetadata adds metadata for the user
SetMetadata(metadata ...*Metadata) database.Change
// RemoveMetadata removes the metadata for the user
// Use one of the following conditions to specify which metadata to remove:
// - [userMetadataConditions.MetadataKeyCondition]
@@ -74,6 +68,8 @@ type userChanges interface {
type userColumns interface {
PrimaryKeyColumns() []database.Column
InstanceIDColumn() database.Column
IDColumn() database.Column
UsernameColumn() database.Column
StateColumn() database.Column
TypeColumn() database.Column
@@ -98,18 +94,32 @@ type humanConditions interface {
NicknameCondition(op database.TextOperation, nickname string) database.Condition
DisplayNameCondition(op database.TextOperation, displayName string) database.Condition
PreferredLanguageCondition(lang language.Tag) database.Condition
EmailCondition(op database.TextOperation, email string) database.Condition
PhoneCondition(op database.TextOperation, phone string) database.Condition
PasskeyIDCondition(passkeyID string) database.Condition
IdentityProviderIDCondition(idpID string) database.Condition
ProvidedUserIDCondition(providedUserID string) database.Condition
ProvidedUsernameCondition(username string) database.Condition
humanPasskeyConditions
// EmailCondition searches for the given email in both verified and unverified email columns
EmailCondition(op database.TextOperation, email string) database.Condition
// UnverifiedEmailCondition searches for the given email in the unverified email column
UnverifiedEmailCondition(op database.TextOperation, email string) database.Condition
// VerifiedEmailCondition searches for the given email in the verified email column
VerifiedEmailCondition(op database.TextOperation, email string) database.Condition
// PhoneCondition searches for the given phone number in both verified and unverified phone number columns
PhoneCondition(op database.TextOperation, phone string) database.Condition
// UnverifiedPhoneCondition searches for the given phone number in the unverified phone number column
UnverifiedPhoneCondition(op database.TextOperation, phone string) database.Condition
// VerifiedPhoneCondition searches for the given phone number in the verified phone number column
VerifiedPhoneCondition(op database.TextOperation, phone string) database.Condition
ExistsPasskey(condition database.Condition) database.Condition
PasskeyConditions() HumanPasskeyConditions
// ExistsVerification(condition database.Condition) database.Condition
// VerificationConditions() HumanVerificationConditions
ExistsIdentityProviderLink(condition database.Condition) database.Condition
IdentityProviderLinkConditions() HumanIdentityProviderLinkConditions
}
type humanChanges interface {
userChanges
// SetFirstName sets the first name field
SetFirstName(firstName string) database.Change
// SetLastName sets the last name field
@@ -127,99 +137,148 @@ type humanChanges interface {
// SetAvatarKey sets the avatar key field
// If avatarKey is nil, it will be set to NULL in the database
SetAvatarKey(avatarKey *string) database.Change
// SetMultifactorInitializationSkippedAt sets the multifactor initialization skipped at field
SetMultifactorInitializationSkippedAt(skippedAt time.Time) database.Change
// SetPassword sets the password based on the verification
SetPassword(verification VerificationType) database.Change
// SetPasswordChangeRequired sets whether a password change is required
SetPasswordChangeRequired(required bool) database.Change
// CheckPassword sets the password check based on the check type
// * [CheckTypeFailed] increments failed attempts
// * [CheckTypeSucceeded] to mark the check as succeeded, removes the check and updates verified at time
CheckPassword(check PasswordCheckType) database.Change
// SkipMultifactorInitializationAt sets the multifactor initialization skipped at field
SkipMultifactorInitializationAt(skippedAt time.Time) database.Change
// SkipMultifactorInitializationAt sets the multifactor initialization skipped at field
SkipMultifactorInitialization() database.Change
// SetVerification sets the verification based on the verification type
SetVerification(id string, verification VerificationType) database.Change
SetVerification(verification VerificationType) database.Change
humanPasswordChanges
humanEmailChanges
humanPhoneChanges
humanTOTPChanges
identityProviderLinkChanges
humanPasskeyChanges
inviteChanges
}
type humanPasswordChanges interface {
// SetPassword overwrites the password field.
// It resets the password verification and the last successful password check time.
SetPassword(hash string) database.Change
// SetResetPassword handles the password reset process based on the verification type:
// * [VerificationTypeInit]: to initialize password reset, a verification will be created. The current password remains unchanged
// * [VerificationTypeSucceeded]: to mark the password as reset and remove the verification. The current password remains unchanged use [humanPasswordChanges.SetPassword] to set the new password.
// * [VerificationTypeUpdate]: to update the existing password reset verification. If a new code is requested, use [VerificationTypeInit].
// * [VerificationTypeFailed]: to increment the failed attempts of the verification.
SetResetPasswordVerification(verification VerificationType) database.Change
// SetPasswordChangeRequired sets whether a password change is required
SetPasswordChangeRequired(required bool) database.Change
// SetLastSuccessfulPasswordCheck sets the last successful password check time
// If checkedAt is zero, it will be set to NOW()
SetLastSuccessfulPasswordCheck(checkedAt time.Time) database.Change
// IncrementPasswordFailedAttempts increments the password failed attempts
IncrementPasswordFailedAttempts() database.Change
// ResetPasswordFailedAttempts resets the password failed attempts
ResetPasswordFailedAttempts() database.Change
}
type humanEmailChanges interface {
// SetEmail sets the email based on the verification
// * [VerificationTypeInit] to initialize email verification, previously verified email remains verified
// * [VerificationTypeVerified] to mark email as verified, a verification must exist
// * [VerificationTypeUpdate] to update email verification, a verification must exist (e.g. resend code)
// * [VerificationTypeSkipped] to skip email verification, existing verification is removed (e.g. admin set email)
SetEmail(verification VerificationType) database.Change
// CheckEmailOTP sets the OTP Email based on the check
// * [CheckTypeInit] to initialize a new check, previous check is overwritten
// * [CheckTypeFailed] increments failed attempts
// * [CheckTypeSucceeded] to mark the check as succeeded, removes the check and updates verified at time
CheckEmailOTP(check CheckType) database.Change
// EnableEmailOTPAt enables the OTP Email
// SetEmail sets the verified email address
SetEmail(address string) database.Change
// SetUnverifiedEmail sets the unverified email address
// Make sure to add [humanEmailChanges.SetEmailVerification] to the changes list.
SetUnverifiedEmail(address string) database.Change
// SetEmailVerification sets the email verification based on the verification
// * [VerificationTypeInit]: to overwrite a email verification, the previously verified email address remains verified.
// * [VerificationTypeSucceeded]: to mark the unverified email address as verified and remove the verification.
// * [VerificationTypeUpdate]: to update the existing email verification. If a new code is requested, use [VerificationTypeInit].
// * [VerificationTypeFailed]: to increment the failed attempts of the verification.
SetEmailVerification(verification VerificationType) database.Change
// EnableEmailOTPAt enables the email OTP
// If enabledAt is zero, it will be set to NOW()
EnableEmailOTPAt(enabledAt time.Time) database.Change
// EnableEmailOTP sets the enabled at time to NOW()
EnableEmailOTP() database.Change
// DisableEmailOTP clears the enabled at time
DisableEmailOTP() database.Change
// SetLastSuccessfulEmailOTPCheck sets the last successful email OTP check time
// If checkedAt is zero, it will be set to NOW()
// It resets the failed attempts
SetLastSuccessfulEmailOTPCheck(checkedAt time.Time) database.Change
// IncrementEmailOTPFailedAttempts increments the email OTP failed attempts
IncrementEmailOTPFailedAttempts() database.Change
// ResetEmailOTPFailedAttempts resets the email OTP failed attempts
ResetEmailOTPFailedAttempts() database.Change
}
type humanPhoneChanges interface {
// SetPhone sets the phone based on the verification
// * [VerificationTypeInit] to initialize phone verification, previously verified phone remains verified
// * [VerificationTypeVerified] to mark phone as verified, a verification must exist
// * [VerificationTypeUpdate] to update phone verification, a verification must exist (e.g. resend code)
// * [VerificationTypeSkipped] to skip phone verification, existing verification is removed (e.g. admin set phone)
SetPhone(verification VerificationType) database.Change
// SetPhone sets the verified phone number
SetPhone(number string) database.Change
// SetUnverifiedPhone sets the unverified phone number
// Make sure to add [humanPhoneChanges.SetPhoneVerification] to the changes list.
SetUnverifiedPhone(number string) database.Change
// SetPhoneVerification sets the phone verification based on the verification
// * [VerificationTypeInit]: to overwrite a phone verification, the previously verified phone number remains verified.
// * [VerificationTypeSucceeded]: to mark the unverified phone number as verified and remove the verification.
// * [VerificationTypeUpdate]: to update the existing phone verification. If a new code is requested, use [VerificationTypeInit].
// * [VerificationTypeFailed]: to increment the failed attempts of the verification.
SetPhoneVerification(verification VerificationType) database.Change
// RemovePhone removes the phone number
RemovePhone() database.Change
// CheckSMSOTP sets the OTP SMS based on the check
// * [CheckTypeInit] to initialize a new check, previous check is overwritten
// * [CheckTypeFailed] increments failed attempts
// * [CheckTypeSucceeded] to mark the check as succeeded, removes the check and updates verified at time
CheckSMSOTP(check CheckType) database.Change
// EnableSMSOTPAt enables the OTP SMS
// EnableSMSOTPAt enables the SMS OTP
// If enabledAt is zero, it will be set to NOW()
EnableSMSOTPAt(enabledAt time.Time) database.Change
// EnableSMSOTP sets the enabled at time to NOW()
EnableSMSOTP() database.Change
// DisableSMSOTP clears the enabled at time
DisableSMSOTP() database.Change
// SetLastSuccessfulSMSOTPCheck sets the last successful SMS OTP check time
// If checkedAt is zero, it will be set to NOW()
// It resets the failed attempts
SetLastSuccessfulSMSOTPCheck(checkedAt time.Time) database.Change
// IncrementSMSOTPFailedAttempts increments the SMS OTP failed attempts
IncrementSMSOTPFailedAttempts() database.Change
// ResetSMSOTPFailedAttempts resets the SMS OTP failed attempts
ResetSMSOTPFailedAttempts() database.Change
}
type humanTOTPChanges interface {
// SetTOTP changes the TOTP secret based on the verification
// * [VerificationTypeInit] to initialize totp verification, previously verified totp remains verified
// * [VerificationTypeVerified] to mark totp as verified, a verification must exist
// * [VerificationTypeUpdate] to update totp verification, a verification must exist (e.g. resend code)
// * [VerificationTypeSkipped] to skip totp verification, existing verification is removed (e.g. admin set totp)
SetTOTP(verification VerificationType) database.Change
// SetTOTPCheck sets the TOTP check based on the check type
// * [CheckTypeFailed] increments failed attempts
// * [CheckTypeSucceeded] to mark the check as succeeded, removes the check and updates verified at time
// * [CheckTypeInit] is not allowed for TOTP
CheckTOTP(check CheckType) database.Change
// SetTOTP changes the TOTP secret and verification timestamp
SetTOTPSecret(secret *crypto.CryptoValue) database.Change
// SetTOTPVerifiedAt sets the TOTP verified at time
// If verifiedAt is zero, it will be set to NOW()
SetTOTPVerifiedAt(verifiedAt time.Time) database.Change
// RemoveTOTP removes the TOTP
RemoveTOTP() database.Change
// SetLastSuccessfulTOTPCheck sets the last successful TOTP check time
// If checkedAt is zero, it will be set to NOW()
// It resets the failed attempts
SetLastSuccessfulTOTPCheck(checkedAt time.Time) database.Change
// IncrementTOTPFailedAttempts increments the TOTP failed attempts
IncrementTOTPFailedAttempts() database.Change
// ResetTOTPFailedAttempts resets the TOTP failed attempts
ResetTOTPFailedAttempts() database.Change
}
type identityProviderLinkChanges interface {
// AddIdentityProviderLink adds or updates an identity provider link
AddIdentityProviderLink(link *IdentityProviderLink) database.Change
UpdateIdentityProviderLink(changes ...database.Change) database.Change
UpdateIdentityProviderLink(condition database.Condition, changes ...database.Change) database.Change
// RemoveIdentityProviderLink removes an identity provider link based on the condition
RemoveIdentityProviderLink(providerID, providedUserID string) database.Change
// SetIdentityProviderLinkUsername sets the username for an identity provider link
SetIdentityProviderLinkUsername(providerID, providedUserID, username string) database.Change
SetIdentityProviderLinkUsername(username string) database.Change
// SetIdentityProviderLinkProvidedID sets the provided user ID for an identity provider link
SetIdentityProviderLinkProvidedID(providerID, currentProvidedUserID, newProvidedUserID string) database.Change
SetIdentityProviderLinkProvidedID(providedUserID string) database.Change
}
type inviteChanges interface {
// SetInviteVerification sets the invite verification based on the verification type:
// * [VerificationTypeInit]: to initialize invite verification, a verification will be created. The current accepted at time remains unchanged
// * [VerificationTypeSucceeded]: to mark the invite as accepted and remove the verification. The current accepted at time remains unchanged use [inviteChanges.AcceptInvite] to set the accepted at time.
// * [VerificationTypeUpdate]: to update the existing invite verification. If a new code is requested, use [VerificationTypeInit].
// * [VerificationTypeFailed]: to increment the failed attempts of the verification.
SetInviteVerification(verification VerificationType) database.Change
}
type HumanIdentityProviderLinkConditions interface {
ProviderIDCondition(providerID string) database.Condition
ProvidedUserIDCondition(providedUserID string) database.Condition
ProvidedUsernameCondition(op database.TextOperation, username string) database.Condition
}
type humanColumns interface {
@@ -256,7 +315,7 @@ type machineChanges interface {
// nil will set the secret to NULL in the database
SetSecret(secret *string) database.Change
// SetAccessTokenType sets the personal access token type field
SetAccessTokenType(tokenType PersonalAccessTokenType) database.Change
SetAccessTokenType(tokenType AccessTokenType) database.Change
// AddKey adds a key for the service account
AddKey(key *MachineKey) database.Change
@@ -273,11 +332,11 @@ type machineColumns interface {
userColumns
}
type humanPasskeyConditions interface {
PasskeyIDCondition(passkeyID string) database.Condition
PasskeyKeyIDCondition(keyID string) database.Condition
PasskeyChallengeCondition(challenge string) database.Condition
PasskeyTypeCondition(passkeyType PasskeyType) database.Condition
type HumanPasskeyConditions interface {
IDCondition(passkeyID string) database.Condition
KeyIDCondition(keyID string) database.Condition
ChallengeCondition(challenge []byte) database.Condition
TypeCondition(passkeyType PasskeyType) database.Condition
}
type humanPasskeyChanges interface {
backend/v3/domain/verification.go
+38 -19
View File
@@ -1,13 +1,18 @@
package domain
import "time"
import (
"time"
"github.com/zitadel/zitadel/internal/crypto"
)
type Verification struct {
Value *string `db:"value"`
Code []byte `db:"code"`
ExpiresAt *time.Time `db:"expires_at"`
FailedAttempts uint8 `db:"failed_attempts"`
VerifiedAt time.Time `db:"verified_at"`
ID string `json:"id" db:"id"`
Code *crypto.CryptoValue `json:"code" db:"code"`
CreatedAt time.Time `json:"createdAt" db:"created_at"`
UpdatedAt time.Time `json:"updatedAt" db:"updated_at"`
ExpiresAt *time.Time `json:"expiresAt" db:"expires_at"`
FailedAttempts uint8 `json:"failedAttempts" db:"failed_attempts"`
}
type VerificationType interface {
@@ -16,15 +21,16 @@ type VerificationType interface {
// VerificationTypeInit indicates that an object which needs verification is created.
type VerificationTypeInit struct {
// ID is the ID of the verification.
// The id must be set if the the object can have multiple verifications.
ID *string
// CreatedAt is the time when the verification was created.
// If zero, the current time will be used.
CreatedAt time.Time
// Expiry is the duration after which the verification expires.
Expiry *time.Duration
// Code is the code to be used for verification.
Code []byte
// Value is the value to be set after successful verification.
Value *string
Code *crypto.CryptoValue
}
// isVerificationType implements [VerificationType].
@@ -32,24 +38,31 @@ func (v *VerificationTypeInit) isVerificationType() {}
var _ VerificationType = (*VerificationTypeInit)(nil)
// VerificationTypeVerified indicates that the verification was successful.
// VerificationTypeSucceeded indicates that the verification was successful.
// If VerifiedAt is zero, the current time will be used.
// If the Value of the verification is present, it is used as the new value to be set.
type VerificationTypeVerified struct {
type VerificationTypeSucceeded struct {
// ID is the ID of the verification.
// The id must be set if the the object can have multiple verifications.
ID *string
// If zero, the current time will be used.
VerifiedAt time.Time
}
// isVerificationType implements [VerificationType].
func (v *VerificationTypeVerified) isVerificationType() {}
func (v *VerificationTypeSucceeded) isVerificationType() {}
var _ VerificationType = (*VerificationTypeVerified)(nil)
var _ VerificationType = (*VerificationTypeSucceeded)(nil)
// VerificationTypeUpdate updates an existing verification.
// Non-nil fields get updated.
type VerificationTypeUpdate struct {
Code []byte
Value *string
// ID is the ID of the verification.
// The id must be set if the the object can have multiple verifications.
ID *string
Code *crypto.CryptoValue
Expiry *time.Duration
// If zero, the current time will be used.
UpdatedAt time.Time
}
// isVerificationType implements [VerificationType].
@@ -58,10 +71,12 @@ func (v *VerificationTypeUpdate) isVerificationType() {}
var _ VerificationType = (*VerificationTypeUpdate)(nil)
// VerificationTypeSkipped indicates that the verification was skipped.
// If Value is present, it is used as the new value to be set.
type VerificationTypeSkipped struct {
VerifiedAt time.Time
Value *string
// ID is the ID of the verification.
// The id must be set if the the object can have multiple verifications.
ID *string
// If zero, the current time will be used.
SkippedAt time.Time
}
// isVerificationType implements [VerificationType].
@@ -70,6 +85,10 @@ func (v *VerificationTypeSkipped) isVerificationType() {}
var _ VerificationType = (*VerificationTypeSkipped)(nil)
type VerificationTypeFailed struct {
// ID is the ID of the verification.
// The id must be set if the the object can have multiple verifications.
ID *string
// If zero, the current time will be used.
FailedAt time.Time
}