Servant.Server.Auth.Token.LevelDB.Schema

Documentation

newtype ModelId

ID of global model index

Constructors

ModelId

Fields

• unModelId :: Int64

Instances

Eq ModelId

Methods

(==) :: ModelId -> ModelId -> Bool

(/=) :: ModelId -> ModelId -> Bool

Ord ModelId

Methods

compare :: ModelId -> ModelId -> Ordering

(<) :: ModelId -> ModelId -> Bool

(<=) :: ModelId -> ModelId -> Bool

(>) :: ModelId -> ModelId -> Bool

(>=) :: ModelId -> ModelId -> Bool

max :: ModelId -> ModelId -> ModelId

min :: ModelId -> ModelId -> ModelId

Read ModelId

Methods

readsPrec :: Int -> ReadS ModelId

readList :: ReadS [ModelId]

readPrec :: ReadPrec ModelId

readListPrec :: ReadPrec [ModelId]

Show ModelId

Methods

showsPrec :: Int -> ModelId -> ShowS

show :: ModelId -> String

showList :: [ModelId] -> ShowS

SafeCopy ModelId

Methods

version :: Version ModelId

kind :: Kind ModelId

getCopy :: Contained (Peek ModelId)

putCopy :: ModelId -> Contained (Encode ModelId)

internalConsistency :: Consistency ModelId

objectProfile :: Profile ModelId

errorTypeName :: Proxy ModelId -> String

Key ModelId Model

Methods

encodeKey :: ModelId -> ByteString

modelId :: ModelId

Global id of model index

data Model

Holds all data for auth server in acid-state container

Constructors

Model

Fields

• _modelUsers :: !(Set UserImplId)

  Holds users by id

• _modelUsersByLogin :: !(Map Login UserImplId)

  Holds users by login (same content as modelUsers)

• _modelUserPerms :: !(Set UserPermId)

  Holds UserPerm

• _modelAuthTokens :: !(Set AuthTokenId)

  Holds AuthToken

• _modelUserRestores :: !(Set UserRestoreId)

  Holds UserRestore

• _modelUserSingleUseCodes :: !(Set UserSingleUseCodeId)

  Holds UserSingleUseCode

• _modelAuthUserGroups :: !(Set AuthUserGroupId)

  Holds AuthUserGroup

• _modelAuthUserGroupUsers :: !(Set AuthUserGroupUsersId)

  Holds AuthUserGroupUsers

• _modelAuthUserGroupPerms :: !(Set AuthUserGroupPermsId)

  Holds AuthUserGroupPerms

• _modelNextUserImplId :: !Int64

  Holds next id for entities

• _modelNextUserPermId :: !Int64

  Holds next id for entities

• _modelNextAuthTokenId :: !Int64

  Holds next id for entities

• _modelNextUserRestoreId :: !Int64

  Holds next id for entities

• _modelNextUserSingleUseCodeId :: !Int64

  Holds next id for entities

• _modelNextAuthUserGroupId :: !Int64

  Holds next id for entities

• _modelNextAuthUserGroupUserId :: !Int64

  Holds next id for entities

• _modelNextAuthUserGroupPermId :: !Int64

  Holds next id for entities

Instances

SafeCopy Model

Methods

version :: Version Model

kind :: Kind Model

getCopy :: Contained (Peek Model)

putCopy :: Model -> Contained (Encode Model)

internalConsistency :: Consistency Model

objectProfile :: Profile Model

errorTypeName :: Proxy Model -> String

Key ModelId Model

Methods

encodeKey :: ModelId -> ByteString

modelUsersByLogin :: Lens' Model (Map Login UserImplId)

modelUsers :: Lens' Model (Set UserImplId)

modelUserSingleUseCodes :: Lens' Model (Set UserSingleUseCodeId)

modelUserRestores :: Lens' Model (Set UserRestoreId)

modelUserPerms :: Lens' Model (Set UserPermId)

modelNextUserSingleUseCodeId :: Lens' Model Int64

modelNextUserRestoreId :: Lens' Model Int64

modelNextUserPermId :: Lens' Model Int64

modelNextUserImplId :: Lens' Model Int64

modelNextAuthUserGroupUserId :: Lens' Model Int64

modelNextAuthUserGroupPermId :: Lens' Model Int64

modelNextAuthUserGroupId :: Lens' Model Int64

modelNextAuthTokenId :: Lens' Model Int64

modelAuthUserGroups :: Lens' Model (Set AuthUserGroupId)

modelAuthUserGroupUsers :: Lens' Model (Set AuthUserGroupUsersId)

modelAuthUserGroupPerms :: Lens' Model (Set AuthUserGroupPermsId)

modelAuthTokens :: Lens' Model (Set AuthTokenId)

newModel :: Model

Defines empty model for new database

class Key i a | i -> a, a -> i where

Helper that defines bijection between key and record

Methods

encodeKey :: i -> ByteString

encodeKey :: (SafeCopy i, Typeable i) => i -> ByteString

Instances

Key UserImplId UserImpl

Methods

encodeKey :: UserImplId -> ByteString

Key UserPermId UserPerm

Methods

encodeKey :: UserPermId -> ByteString

Key AuthTokenId AuthToken

Methods

encodeKey :: AuthTokenId -> ByteString

Key UserRestoreId UserRestore

Methods

encodeKey :: UserRestoreId -> ByteString

Key UserSingleUseCodeId UserSingleUseCode

Methods

encodeKey :: UserSingleUseCodeId -> ByteString

Key AuthUserGroupId AuthUserGroup

Methods

encodeKey :: AuthUserGroupId -> ByteString

Key AuthUserGroupUsersId AuthUserGroupUsers

Methods

encodeKey :: AuthUserGroupUsersId -> ByteString

Key AuthUserGroupPermsId AuthUserGroupPerms

Methods

encodeKey :: AuthUserGroupPermsId -> ByteString

Key ModelId Model

Methods

encodeKey :: ModelId -> ByteString

data LevelDBEnv

Holds together db reference and options for read/write and mutex

Constructors

LevelDBEnv !DB !ReadOptions !WriteOptions !RLock

Instances

Monad m => MonadReader (AuthConfig, LevelDBEnv) (LevelDBBackendT m)

Methods

ask :: LevelDBBackendT m (AuthConfig, LevelDBEnv)

local :: ((AuthConfig, LevelDBEnv) -> (AuthConfig, LevelDBEnv)) -> LevelDBBackendT m a -> LevelDBBackendT m a

reader :: ((AuthConfig, LevelDBEnv) -> a) -> LevelDBBackendT m a

newLevelDBEnv :: MonadIO m => DB -> ReadOptions -> WriteOptions -> m LevelDBEnv

Make new environment for execution of LevelDB operations

load :: (MonadResource m, Key i a, SafeCopy a) => LevelDBEnv -> i -> m (Maybe a)

Load object by id from leveldb

store :: (MonadResource m, Key i a, SafeCopy a) => LevelDBEnv -> i -> a -> m ()

Store object by id in leveldb

remove :: (MonadResource m, Key i a) => LevelDBEnv -> i -> m ()

Remove object by given id in leveldb

modify :: (MonadResource m, MonadMask m, Key i a, SafeCopy a) => LevelDBEnv -> i -> (a -> a) -> m ()

Modify value by id in leveldb

modifyM :: (MonadResource m, MonadMask m, Key i a, SafeCopy a) => LevelDBEnv -> i -> (a -> m a) -> m ()

Modify value by id in leveldb

loadModel :: MonadResource m => LevelDBEnv -> m Model

Load global index from leveldb

storeModel :: MonadResource m => LevelDBEnv -> Model -> m ()

Store glogal index to leveldb

modifyModel :: MonadResource m => LevelDBEnv -> (Model -> Model) -> m ()

Modify global index

modifyModelM :: (MonadResource m, MonadMask m) => LevelDBEnv -> (Model -> m (Model, a)) -> m a

Modify global index

getPagedList :: (MonadResource m, Ord i, Key i a, SafeCopy a) => LevelDBEnv -> Page -> PageSize -> Set i -> m ([WithId i a], Word)

Helper to get paged list of entities

insertRecord

Arguments

:: (MonadResource m, MonadMask m, Key i a, ConvertableKey i, Ord i, SafeCopy a)

=> Lens' Model Int64

Field of model that store counter of the record ids

-> Lens' Model (Set i)

Field of model that store a registry of the record ids

-> a

-> LevelDBEnv

-> m i

Generic way to insert record in the leveldb with track in global registry

selectRecords

Arguments

:: (MonadResource m, Key i a, SafeCopy a)

=> Lens' Model (Set i)

Model field with registry of the records

-> (i -> a -> Bool)

Predicate

-> LevelDBEnv

-> m [WithId i a]

Generic way to select all records that satisfies given predicate

deleteRecords

Arguments

:: (MonadResource m, MonadMask m, Key i a, Ord i, Foldable f)

=> Lens' Model (Set i)

Model field with registry of the records

-> f i

Set of ids of records that should be deleted

-> LevelDBEnv

-> m ()

Generic way to delete several records with respect of global registry

replaceRecord

Arguments

:: (MonadResource m, MonadMask m, Key i a, Ord i, SafeCopy a)

=> Lens' Model (Set i)

Model field with registry of the records

-> i

ID of record

-> a

Value of record

-> LevelDBEnv

-> m ()

Generic way to replace record in registry and leveldb

withId :: WithField s i a -> i

Extract id

withVal :: WithField s i a -> a

Extract value

getUserImplByLogin :: MonadResource m => Login -> LevelDBEnv -> m (Maybe (WithId UserImplId UserImpl))

Getting user from storage by login

listUsersPaged :: MonadResource m => Page -> PageSize -> LevelDBEnv -> m ([WithId UserImplId UserImpl], Word)

Get paged list of users and total count of users

getUserImplPermissions :: MonadResource m => UserImplId -> LevelDBEnv -> m [WithId UserPermId UserPerm]

Get user permissions, ascending by tag

deleteUserPermissions :: (MonadResource m, MonadMask m) => UserImplId -> LevelDBEnv -> m ()

Delete user permissions

insertUserPerm :: (MonadResource m, MonadMask m) => UserPerm -> LevelDBEnv -> m UserPermId

Insertion of new user permission

insertUserImpl :: (MonadResource m, MonadMask m) => UserImpl -> LevelDBEnv -> m UserImplId

Insertion of new user

replaceUserImpl :: (MonadResource m, MonadMask m) => UserImplId -> UserImpl -> LevelDBEnv -> m ()

Replace user with new value

deleteUserImpl :: (MonadResource m, MonadMask m) => UserImplId -> LevelDBEnv -> m ()

Delete user by id

hasPerm :: MonadResource m => UserImplId -> Permission -> LevelDBEnv -> m Bool

Check whether the user has particular permission

getFirstUserByPerm :: MonadResource m => Permission -> LevelDBEnv -> m (Maybe (WithId UserImplId UserImpl))

Get any user with given permission

selectUserImplGroups :: MonadResource m => UserImplId -> LevelDBEnv -> m [WithId AuthUserGroupUsersId AuthUserGroupUsers]

Select user groups and sort them by ascending name

clearUserImplGroups :: (MonadResource m, MonadMask m) => UserImplId -> LevelDBEnv -> m ()

Remove user from all groups

insertAuthUserGroup :: (MonadResource m, MonadMask m) => AuthUserGroup -> LevelDBEnv -> m AuthUserGroupId

Add new user group

insertAuthUserGroupUsers :: (MonadResource m, MonadMask m) => AuthUserGroupUsers -> LevelDBEnv -> m AuthUserGroupUsersId

Add user to given group

insertAuthUserGroupPerms :: (MonadResource m, MonadMask m) => AuthUserGroupPerms -> LevelDBEnv -> m AuthUserGroupPermsId

Add permission to given group

listAuthUserGroupPermissions :: MonadResource m => AuthUserGroupId -> LevelDBEnv -> m [WithId AuthUserGroupPermsId AuthUserGroupPerms]

Get list of permissions of given group

listAuthUserGroupUsers :: MonadResource m => AuthUserGroupId -> LevelDBEnv -> m [WithId AuthUserGroupUsersId AuthUserGroupUsers]

Get list of all users of the group

replaceAuthUserGroup :: (MonadResource m, MonadMask m) => AuthUserGroupId -> AuthUserGroup -> LevelDBEnv -> m ()

Replace record of user group

clearAuthUserGroupUsers :: (MonadResource m, MonadMask m) => AuthUserGroupId -> LevelDBEnv -> m ()

Remove all users from group

clearAuthUserGroupPerms :: (MonadResource m, MonadMask m) => AuthUserGroupId -> LevelDBEnv -> m ()

Remove all permissions from group

deleteAuthUserGroup :: (MonadResource m, MonadMask m) => AuthUserGroupId -> LevelDBEnv -> m ()

Delete user group from storage

listGroupsPaged :: MonadResource m => Page -> PageSize -> LevelDBEnv -> m ([WithId AuthUserGroupId AuthUserGroup], Word)

Get paged list of user groups with total count

setAuthUserGroupName :: (MonadResource m, MonadMask m) => AuthUserGroupId -> Text -> LevelDBEnv -> m ()

Set group name

setAuthUserGroupParent :: (MonadResource m, MonadMask m) => AuthUserGroupId -> Maybe AuthUserGroupId -> LevelDBEnv -> m ()

Set group parent

insertSingleUseCode :: (MonadResource m, MonadMask m) => UserSingleUseCode -> LevelDBEnv -> m UserSingleUseCodeId

Add new single use code

setSingleUseCodeUsed :: (MonadResource m, MonadMask m) => UserSingleUseCodeId -> Maybe UTCTime -> LevelDBEnv -> m ()

Set usage time of the single use code

getUnusedCode :: MonadResource m => SingleUseCode -> UserImplId -> UTCTime -> LevelDBEnv -> m (Maybe (WithId UserSingleUseCodeId UserSingleUseCode))

Find unused code for the user and expiration time greater than the given time

invalidatePermamentCodes :: (MonadResource m, MonadMask m) => UserImplId -> UTCTime -> LevelDBEnv -> m ()

Invalidate all permament codes for user and set use time for them

selectLastRestoreCode :: MonadResource m => UserImplId -> UTCTime -> LevelDBEnv -> m (Maybe (WithId UserRestoreId UserRestore))

Select last valid restoration code by the given current time

insertUserRestore :: (MonadResource m, MonadMask m) => UserRestore -> LevelDBEnv -> m UserRestoreId

Insert new restore code

findRestoreCode :: MonadResource m => UserImplId -> RestoreCode -> UTCTime -> LevelDBEnv -> m (Maybe (WithId UserRestoreId UserRestore))

Find unexpired by the time restore code

replaceRestoreCode :: (MonadResource m, MonadMask m) => UserRestoreId -> UserRestore -> LevelDBEnv -> m ()

Replace restore code with new value

findAuthToken :: MonadResource m => UserImplId -> UTCTime -> LevelDBEnv -> m (Maybe (WithId AuthTokenId AuthToken))

Find first non-expired by the time token for user

findAuthTokenByValue :: MonadResource m => SimpleToken -> LevelDBEnv -> m (Maybe (WithId AuthTokenId AuthToken))

Find token by value

insertAuthToken :: (MonadResource m, MonadMask m) => AuthToken -> LevelDBEnv -> m AuthTokenId

Insert new token

replaceAuthToken :: (MonadResource m, MonadMask m) => AuthTokenId -> AuthToken -> LevelDBEnv -> m ()

Replace auth token with new value

Orphan instances

SafeCopy UserImplId

Methods

version :: Version UserImplId

kind :: Kind UserImplId

getCopy :: Contained (Peek UserImplId)

putCopy :: UserImplId -> Contained (Encode UserImplId)

internalConsistency :: Consistency UserImplId

objectProfile :: Profile UserImplId

errorTypeName :: Proxy UserImplId -> String

SafeCopy UserImpl

Methods

version :: Version UserImpl

kind :: Kind UserImpl

getCopy :: Contained (Peek UserImpl)

putCopy :: UserImpl -> Contained (Encode UserImpl)

internalConsistency :: Consistency UserImpl

objectProfile :: Profile UserImpl

errorTypeName :: Proxy UserImpl -> String

SafeCopy UserPermId

Methods

version :: Version UserPermId

kind :: Kind UserPermId

getCopy :: Contained (Peek UserPermId)

putCopy :: UserPermId -> Contained (Encode UserPermId)

internalConsistency :: Consistency UserPermId

objectProfile :: Profile UserPermId

errorTypeName :: Proxy UserPermId -> String

SafeCopy UserPerm

Methods

version :: Version UserPerm

kind :: Kind UserPerm

getCopy :: Contained (Peek UserPerm)

putCopy :: UserPerm -> Contained (Encode UserPerm)

internalConsistency :: Consistency UserPerm

objectProfile :: Profile UserPerm

errorTypeName :: Proxy UserPerm -> String

SafeCopy AuthTokenId

Methods

version :: Version AuthTokenId

kind :: Kind AuthTokenId

getCopy :: Contained (Peek AuthTokenId)

putCopy :: AuthTokenId -> Contained (Encode AuthTokenId)

internalConsistency :: Consistency AuthTokenId

objectProfile :: Profile AuthTokenId

errorTypeName :: Proxy AuthTokenId -> String

SafeCopy AuthToken

Methods

version :: Version AuthToken

kind :: Kind AuthToken

getCopy :: Contained (Peek AuthToken)

putCopy :: AuthToken -> Contained (Encode AuthToken)

internalConsistency :: Consistency AuthToken

objectProfile :: Profile AuthToken

errorTypeName :: Proxy AuthToken -> String

SafeCopy UserRestoreId

Methods

version :: Version UserRestoreId

kind :: Kind UserRestoreId

getCopy :: Contained (Peek UserRestoreId)

putCopy :: UserRestoreId -> Contained (Encode UserRestoreId)

internalConsistency :: Consistency UserRestoreId

objectProfile :: Profile UserRestoreId

errorTypeName :: Proxy UserRestoreId -> String

SafeCopy UserRestore

Methods

version :: Version UserRestore

kind :: Kind UserRestore

getCopy :: Contained (Peek UserRestore)

putCopy :: UserRestore -> Contained (Encode UserRestore)

internalConsistency :: Consistency UserRestore

objectProfile :: Profile UserRestore

errorTypeName :: Proxy UserRestore -> String

SafeCopy UserSingleUseCodeId

Methods

version :: Version UserSingleUseCodeId

kind :: Kind UserSingleUseCodeId

getCopy :: Contained (Peek UserSingleUseCodeId)

putCopy :: UserSingleUseCodeId -> Contained (Encode UserSingleUseCodeId)

internalConsistency :: Consistency UserSingleUseCodeId

objectProfile :: Profile UserSingleUseCodeId

errorTypeName :: Proxy UserSingleUseCodeId -> String

SafeCopy UserSingleUseCode

Methods

version :: Version UserSingleUseCode

kind :: Kind UserSingleUseCode

getCopy :: Contained (Peek UserSingleUseCode)

putCopy :: UserSingleUseCode -> Contained (Encode UserSingleUseCode)

internalConsistency :: Consistency UserSingleUseCode

objectProfile :: Profile UserSingleUseCode

errorTypeName :: Proxy UserSingleUseCode -> String

SafeCopy AuthUserGroupId

Methods

version :: Version AuthUserGroupId

kind :: Kind AuthUserGroupId

getCopy :: Contained (Peek AuthUserGroupId)

putCopy :: AuthUserGroupId -> Contained (Encode AuthUserGroupId)

internalConsistency :: Consistency AuthUserGroupId

objectProfile :: Profile AuthUserGroupId

errorTypeName :: Proxy AuthUserGroupId -> String

SafeCopy AuthUserGroup

Methods

version :: Version AuthUserGroup

kind :: Kind AuthUserGroup

getCopy :: Contained (Peek AuthUserGroup)

putCopy :: AuthUserGroup -> Contained (Encode AuthUserGroup)

internalConsistency :: Consistency AuthUserGroup

objectProfile :: Profile AuthUserGroup

errorTypeName :: Proxy AuthUserGroup -> String

SafeCopy AuthUserGroupUsersId

Methods

version :: Version AuthUserGroupUsersId

kind :: Kind AuthUserGroupUsersId

getCopy :: Contained (Peek AuthUserGroupUsersId)

putCopy :: AuthUserGroupUsersId -> Contained (Encode AuthUserGroupUsersId)

internalConsistency :: Consistency AuthUserGroupUsersId

objectProfile :: Profile AuthUserGroupUsersId

errorTypeName :: Proxy AuthUserGroupUsersId -> String

SafeCopy AuthUserGroupUsers

Methods

version :: Version AuthUserGroupUsers

kind :: Kind AuthUserGroupUsers

getCopy :: Contained (Peek AuthUserGroupUsers)

putCopy :: AuthUserGroupUsers -> Contained (Encode AuthUserGroupUsers)

internalConsistency :: Consistency AuthUserGroupUsers

objectProfile :: Profile AuthUserGroupUsers

errorTypeName :: Proxy AuthUserGroupUsers -> String

SafeCopy AuthUserGroupPermsId

Methods

version :: Version AuthUserGroupPermsId

kind :: Kind AuthUserGroupPermsId

getCopy :: Contained (Peek AuthUserGroupPermsId)

putCopy :: AuthUserGroupPermsId -> Contained (Encode AuthUserGroupPermsId)

internalConsistency :: Consistency AuthUserGroupPermsId

objectProfile :: Profile AuthUserGroupPermsId

errorTypeName :: Proxy AuthUserGroupPermsId -> String

SafeCopy AuthUserGroupPerms

Methods

version :: Version AuthUserGroupPerms

kind :: Kind AuthUserGroupPerms

getCopy :: Contained (Peek AuthUserGroupPerms)

putCopy :: AuthUserGroupPerms -> Contained (Encode AuthUserGroupPerms)

internalConsistency :: Consistency AuthUserGroupPerms

objectProfile :: Profile AuthUserGroupPerms

errorTypeName :: Proxy AuthUserGroupPerms -> String

(SafeCopy k, SafeCopy v) => SafeCopy (WithField i k v)

Methods

version :: Version (WithField i k v)

kind :: Kind (WithField i k v)

getCopy :: Contained (Peek (WithField i k v))

putCopy :: WithField i k v -> Contained (Encode (WithField i k v))

internalConsistency :: Consistency (WithField i k v)

objectProfile :: Profile (WithField i k v)

errorTypeName :: Proxy (WithField i k v) -> String