Enum PGConnection 

pub enum PGConnection {
    Pool(Pool<Postgres>, Cache<VersionId, Resource>),
    Transaction(Arc<Mutex<Transaction<'static, Postgres>>>, Cache<VersionId, Resource>),
}

Connection types supported by the repository traits.

Variants

Pool(Pool<Postgres>, Cache<VersionId, Resource>)

Transaction(Arc<Mutex<Transaction<'static, Postgres>>>, Cache<VersionId, Resource>)

Implementations

impl PGConnection

pub fn pool(pool: Pool<Postgres>) -> Self

pub fn cache(&self) -> &Cache<VersionId, Resource>

Trait Implementations

impl Clone for PGConnection

fn clone(&self) -> PGConnection

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for PGConnection

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl FHIRRepository for PGConnection

async fn create( &self, tenant: &TenantId, project: &ProjectId, author: &UserTokenClaims, fhir_version: &SupportedFHIRVersions, resource: &mut Resource, ) -> Result<Resource, OperationOutcomeError>

async fn delete( &self, tenant: &TenantId, project: &ProjectId, author: &UserTokenClaims, fhir_version: &SupportedFHIRVersions, resource: &mut Resource, id: &str, ) -> Result<Resource, OperationOutcomeError>

async fn update( &self, tenant: &TenantId, project: &ProjectId, author: &UserTokenClaims, fhir_version: &SupportedFHIRVersions, resource: &mut Resource, id: &str, ) -> Result<Resource, OperationOutcomeError>

async fn read_by_version_ids( &self, tenant_id: &TenantId, project_id: &ProjectId, version_ids: &[&VersionId], cache_policy: CachePolicy, ) -> Result<Vec<Resource>, OperationOutcomeError>

async fn read_latest( &self, tenant_id: &TenantId, project_id: &ProjectId, resource_type: &ResourceType, resource_id: &ResourceId, ) -> Result<Option<Resource>, OperationOutcomeError>

async fn history( &self, tenant_id: &TenantId, project_id: &ProjectId, request: &HistoryRequest, ) -> Result<Vec<ResourceHistoryValue>, OperationOutcomeError>

fn in_transaction(&self) -> bool

async fn transaction<'a>( &'a self, is_updating_sequence: bool, ) -> Result<Self, OperationOutcomeError>

async fn commit(self) -> Result<(), OperationOutcomeError>

async fn rollback(self) -> Result<(), OperationOutcomeError>

impl Login for PGConnection

async fn login( &self, tenant: &TenantId, method: &LoginMethod, ) -> Result<LoginResult, OperationOutcomeError>

impl Migrate for PGConnection

async fn migrate(&self) -> Result<(), OperationOutcomeError>

impl<Key: AsRef<str> + Send + Sync> ProjectAuthAdmin<CreateAuthorizationCode, AuthorizationCode, AuthorizationCodeSearchClaims, AuthorizationCode, Key> for PGConnection

async fn create( &self, tenant: &TenantId, project: &ProjectId, authorization_code: CreateAuthorizationCode, ) -> Result<AuthorizationCode, OperationOutcomeError>

async fn read( &self, tenant: &TenantId, project: &ProjectId, code: &Key, ) -> Result<Option<AuthorizationCode>, OperationOutcomeError>

async fn update( &self, _tenant: &TenantId, _project: &ProjectId, _model: AuthorizationCode, ) -> Result<AuthorizationCode, OperationOutcomeError>

async fn delete( &self, tenant: &TenantId, project: &ProjectId, code: &Key, ) -> Result<(), OperationOutcomeError>

async fn search( &self, tenant: &TenantId, project: &ProjectId, clauses: &AuthorizationCodeSearchClaims, ) -> Result<Vec<AuthorizationCode>, OperationOutcomeError>

impl<Key: AsRef<str> + Send + Sync> ProjectAuthAdmin<CreateMembership, Membership, MembershipSearchClaims, Membership, Key> for PGConnection

async fn create( &self, tenant: &TenantId, project: &ProjectId, new_membership: CreateMembership, ) -> Result<Membership, OperationOutcomeError>

async fn read( &self, tenant: &TenantId, project: &ProjectId, id: &Key, ) -> Result<Option<Membership>, OperationOutcomeError>

async fn update( &self, tenant: &TenantId, project: &ProjectId, model: Membership, ) -> Result<Membership, OperationOutcomeError>

async fn delete( &self, tenant: &TenantId, project: &ProjectId, id: &Key, ) -> Result<(), OperationOutcomeError>

async fn search( &self, tenant: &TenantId, project: &ProjectId, clauses: &MembershipSearchClaims, ) -> Result<Vec<Membership>, OperationOutcomeError>

impl ProjectAuthAdmin<CreateScope, Scope, ScopeSearchClaims, UpdateScope, ScopeKey> for PGConnection

async fn create( &self, tenant: &TenantId, project: &ProjectId, new_scope: CreateScope, ) -> Result<Scope, OperationOutcomeError>

async fn read( &self, tenant: &TenantId, project: &ProjectId, key: &ScopeKey, ) -> Result<Option<Scope>, OperationOutcomeError>

async fn update( &self, tenant: &TenantId, project: &ProjectId, model: UpdateScope, ) -> Result<Scope, OperationOutcomeError>

async fn delete( &self, tenant: &TenantId, project: &ProjectId, key: &ScopeKey, ) -> Result<(), OperationOutcomeError>

async fn search( &self, tenant: &TenantId, project: &ProjectId, clauses: &ScopeSearchClaims, ) -> Result<Vec<Scope>, OperationOutcomeError>

impl RateLimit for PGConnection

fn check<'a>( &'a self, rate_key: &'a str, max: i32, points: i32, window_in_seconds: i32, ) -> Pin<Box<dyn Future<Output = Result<i32, RateLimitError>> + Send + 'a>>

Returns the current points after the operation. Note use of box and pin so can satisfy dynamic dispatch requirements.

impl Repository for PGConnection

impl ResourceSequential for PGConnection

async fn get_sequence( &self, tenant_id: &TenantId, sequence_id: u64, count: Option<u64>, ) -> Result<Vec<ResourcePollingValue>, OperationOutcomeError>

impl SystemAdmin<User, UserSearchClauses> for PGConnection

async fn search( &self, clauses: &UserSearchClauses, ) -> Result<Vec<User>, OperationOutcomeError>

impl<Key: AsRef<str> + Send + Sync> TenantAuthAdmin<CreateAuthorizationCode, AuthorizationCode, AuthorizationCodeSearchClaims, AuthorizationCode, Key> for PGConnection

async fn create( &self, tenant: &TenantId, authorization_code: CreateAuthorizationCode, ) -> Result<AuthorizationCode, OperationOutcomeError>

async fn read( &self, tenant: &TenantId, code: &Key, ) -> Result<Option<AuthorizationCode>, OperationOutcomeError>

async fn update( &self, _tenant: &TenantId, _model: AuthorizationCode, ) -> Result<AuthorizationCode, OperationOutcomeError>

async fn delete( &self, tenant: &TenantId, code: &Key, ) -> Result<(), OperationOutcomeError>

async fn search( &self, tenant: &TenantId, clauses: &AuthorizationCodeSearchClaims, ) -> Result<Vec<AuthorizationCode>, OperationOutcomeError>

impl<Key: AsRef<str> + Send + Sync> TenantAuthAdmin<CreateProject, Project, ProjectSearchClaims, Project, Key> for PGConnection

async fn create( &self, tenant: &TenantId, new_project: CreateProject, ) -> Result<Project, OperationOutcomeError>

async fn read( &self, tenant: &TenantId, id: &Key, ) -> Result<Option<Project>, OperationOutcomeError>

async fn update( &self, tenant: &TenantId, model: Project, ) -> Result<Project, OperationOutcomeError>

async fn delete( &self, tenant: &TenantId, id: &Key, ) -> Result<(), OperationOutcomeError>

async fn search( &self, tenant: &TenantId, claims: &ProjectSearchClaims, ) -> Result<Vec<Project>, OperationOutcomeError>

impl<Key: AsRef<str> + Send + Sync> TenantAuthAdmin<CreateTenant, Tenant, TenantSearchClaims, Tenant, Key> for PGConnection

async fn create( &self, _tenant: &TenantId, new_tenant: CreateTenant, ) -> Result<Tenant, OperationOutcomeError>

async fn read( &self, _tenant: &TenantId, id: &Key, ) -> Result<Option<Tenant>, OperationOutcomeError>

async fn update( &self, _tenant: &TenantId, model: Tenant, ) -> Result<Tenant, OperationOutcomeError>

async fn delete( &self, _tenant: &TenantId, id: &Key, ) -> Result<(), OperationOutcomeError>

async fn search( &self, _tenant: &TenantId, claims: &TenantSearchClaims, ) -> Result<Vec<Tenant>, OperationOutcomeError>

impl<Key: AsRef<str> + Send + Sync> TenantAuthAdmin<CreateUser, User, UserSearchClauses, UpdateUser, Key> for PGConnection

async fn create( &self, tenant: &TenantId, new_user: CreateUser, ) -> Result<User, OperationOutcomeError>

async fn read( &self, tenant: &TenantId, id: &Key, ) -> Result<Option<User>, OperationOutcomeError>

async fn update( &self, tenant: &TenantId, user: UpdateUser, ) -> Result<User, OperationOutcomeError>

async fn delete( &self, tenant: &TenantId, id: &Key, ) -> Result<(), OperationOutcomeError>

async fn search( &self, tenant: &TenantId, clauses: &UserSearchClauses, ) -> Result<Vec<User>, OperationOutcomeError>