Struct ScopedAppService 

pub struct ScopedAppService<'repository> {
    pub domains: Arc<dyn DomainRepository + 'repository>,
    pub studies: Arc<dyn StudyRepository + 'repository>,
    pub study_domains: Arc<dyn StudyDomainRepository + 'repository>,
    pub study_governance: Arc<dyn StudyGovernanceRepository + 'repository>,
    pub assets: Arc<dyn AssetRepository + 'repository>,
    pub variables: Arc<dyn VariableRepository + 'repository>,
    pub vocabularies: Arc<dyn VocabularyRepository + 'repository>,
    pub entities: Arc<dyn EntityRepository + 'repository>,
    pub transformations: Arc<dyn TransformationRepository + 'repository>,
    pub tags: Arc<dyn TagRepository + 'repository>,
    /* private fields */
}

Fields

domains: Arc<dyn DomainRepository + 'repository>

studies: Arc<dyn StudyRepository + 'repository>

study_domains: Arc<dyn StudyDomainRepository + 'repository>

study_governance: Arc<dyn StudyGovernanceRepository + 'repository>

assets: Arc<dyn AssetRepository + 'repository>

variables: Arc<dyn VariableRepository + 'repository>

vocabularies: Arc<dyn VocabularyRepository + 'repository>

entities: Arc<dyn EntityRepository + 'repository>

transformations: Arc<dyn TransformationRepository + 'repository>

tags: Arc<dyn TagRepository + 'repository>

Implementations

impl ScopedAppService<'static>

pub async fn authorize_acquisition( &self, session: &DataStoreSession, request: &mut AcquisitionRequest, authority: AcquisitionAuthorization<'_>, ) -> Result<(), AppError>

Resolve and freeze the destination independently of external source access. A shared-source name grants only its explicitly configured endpoint/Study.

pub async fn ingest_acquisition( &self, session: &mut DataStoreSession, status: SessionStatusPayload, admission: &AcquisitionAdmission, input: AcquisitionInput, outbound: &OutboundPolicy, ) -> Result<Value, AppError>

impl ScopedAppService<'static>

pub fn catalogue_datastore_id(&self) -> Result<PublicUuid, AppError>

Durable origin of the retained, authenticated metadata capability.

pub fn catalogue_reference_id( &self, reference: ObjectRef, kind: ObjectKind, ) -> Result<PublicUuid, AppError>

Checks origin and kind before any metadata lookup. A reference is never authority: callers still resolve it through the authenticated repositories.

pub fn catalogue_domain_selector( &self, selector: DomainSelector, ) -> Result<DomainSelector, AppError>

pub fn catalogue_study_selector( &self, selector: StudySelector, ) -> Result<StudySelector, AppError>

pub async fn add_catalogue_study( &self, request: AddStudyRequest, ) -> Result<StudyAddResult, AppError>

pub async fn resolve_catalogue_asset( &self, selector: AssetSelector, ) -> Result<(StudyRecord, AssetVersionCatalog, Option<VersionId>), AppError>

pub async fn list_catalogue_datasets( &self, study: StudySelector, include_versions: bool, ) -> Result<(StudyRecord, StudyDatasetList), AppError>

One orchestration owner for both remote and local adapters.

pub async fn list_catalogue_assets( &self, selector: StudySelector, asset_type: Option<AssetType>, ) -> Result<(StudyRecord, Vec<SafeAssetSummary>), AppError>

pub async fn read_catalogue_datafile( &self, selector: DataFileSelector, version: Option<&str>, ) -> Result<(StudyRecord, DataFileMetadata), AppError>

pub async fn read_catalogue_dataset( &self, selector: DatasetSelector, with_variables: bool, ) -> Result<DatasetMetadataResult, AppError>

impl ScopedAppService<'static>

pub async fn search_catalogue_studies( &self, request: SearchStudiesRequest, ) -> Result<(Vec<StudySummary>, Option<String>), AppError>

pub async fn search_catalogue_datasets( &self, request: SearchDatasetsRequest, ) -> Result<(Vec<DatasetSummary>, Option<String>), AppError>

pub async fn search_catalogue_datafiles( &self, request: SearchDataFilesRequest, ) -> Result<(Vec<DataFileSummary>, Option<String>), AppError>

impl ScopedAppService<'static>

pub async fn datafile_to_dataset( &self, session: &mut DataStoreSession, request: DataFileToDatasetRequest, ) -> Result<DatasetMaterialization, AppError>

impl ScopedAppService<'static>

pub async fn transform_catalogue_dataset( &self, session: &mut DataStoreSession, request: DatasetTransformRequest, ) -> Result<DatasetMaterialization, AppError>

Resolve every supplied constraint before reserving the independent Output Study.

impl ScopedAppService<'static>

pub async fn admit_disclosure<'session>( session: &'session mut DataStoreSession, request: DisclosureRequest, ) -> Result<SessionDisclosure<'session>, AppError>

One trusted content-admission seam. Correlation and origin come only from the retained configured Session, never caller-supplied UUIDs.

pub async fn governance_history( session: &mut DataStoreSession, study: StudySelector, after: DateTime<Utc>, after_id: Uuid, limit: u32, ) -> Result<Vec<Value>, AppError>

Non-content readback from the actual ledger Dataset. Metadata authorizes the current custodian and supplies identities; it cannot replace the ledger.

pub async fn reclassify_catalogue_asset( session: &mut DataStoreSession, selector: AssetSelector, revision: u64, risk: AssetRisk, justification: &str, ) -> Result<AssetClassification, AppError>

impl ScopedAppService<'static>

pub async fn prepare_semantic_response<'session>( session: &'session mut DataStoreSession, status: SessionStatusPayload, request: ProtocolRequest, ) -> Result<PreparedSemanticResponse<'session>, AppError>

Resolve provenance, admit under one policy snapshot and freeze the JSON result. A transport can only consume the retained result; it cannot reopen a selector or select a different set of contributing versions.

impl ScopedAppService<'static>

pub async fn list_governed_asset_duo( &self, request: AssetDuoListRequest, ) -> Result<GovernedAssetDuo, AppError>

pub async fn clear_governed_asset_duo( &self, request: AssetDuoClearRequest, ) -> Result<GovernedAssetDuo, AppError>

pub async fn replace_governed_asset_duo( &self, request: AssetDuoReplaceRequest, ) -> Result<GovernedAssetDuo, AppError>

impl ScopedAppService<'static>

pub async fn grant_governed_study_access( &self, request: StudyAccessGrantRequest, ) -> Result<(StudyRecord, StudyAccessGrant), AppError>

pub async fn add_governed_study_domain( &self, request: AddStudyDomainRequest, ) -> Result<StudyRegistration, AppError>

Resolve every supplied constraint against the retained Datastore before changing the Study’s Domain memberships.

impl ScopedAppService<'static>

pub async fn list_governed_study_access( &self, request: StudyAccessListRequest, ) -> Result<(StudyRecord, StudyAccessGrantList), AppError>

impl ScopedAppService<'static>

pub async fn revoke_governed_study_access( &self, request: StudyAccessRevokeRequest, ) -> Result<(StudyRecord, StudyAccessRevocation), AppError>

impl ScopedAppService<'static>

pub async fn list_governed_study_custodians( &self, request: StudyCustodiansListRequest, ) -> Result<(StudyRecord, StudyCustodianList), AppError>

impl ScopedAppService<'static>

pub async fn add_governed_delegate_custodian( &self, request: StudyCustodianMutationRequest, ) -> Result<(StudyRecord, StudyCustodian), AppError>

impl ScopedAppService<'static>

pub async fn transfer_governed_primary_custodian( &self, request: StudyCustodianMutationRequest, ) -> Result<(StudyRecord, StudyPrimaryCustodianshipTransfer), AppError>

impl ScopedAppService<'static>

pub async fn remove_governed_delegate_custodian( &self, request: StudyCustodianMutationRequest, ) -> Result<(StudyRecord, StudyDelegateCustodianRemoval), AppError>

impl ScopedAppService<'static>

pub async fn list_governed_study_duo( &self, request: StudyDuoListRequest, ) -> Result<(StudyRecord, StudyDuoRestrictionList), AppError>

impl ScopedAppService<'static>

pub async fn replace_governed_study_duo( &self, request: StudyDuoReplaceRequest, ) -> Result<(StudyRecord, StudyDuoRestrictionReplacement), AppError>

impl ScopedAppService<'static>

pub async fn plan_governed_delete( &self, request: &GovernedDeleteRequest, authenticated_actor: &str, ) -> Result<GovernedDeletePlan, AppError>

Resolve names, reference origin, supplied scopes and immutable versions before planning. Execution calls this same boundary once and retains the resulting target throughout archive and cleanup.

impl ScopedAppService<'static>

pub async fn execute_governed_delete( &self, session: &mut DataStoreSession, request: GovernedDeleteRequest, authenticated_actor: &str, ) -> Result<GovernedDeleteOutcome, AppError>

impl ScopedAppService<'static>

pub async fn plan_governed_withdrawal( &self, request: &DatasetWithdrawRequest, authenticated_actor: &str, ) -> Result<WithdrawDatasetVersionRequest, AppError>

A pinned reference is explicit version intent. A moving latest selector is never valid for withdrawal, even when it currently matches the pin.

pub async fn execute_governed_withdrawal( &self, session: &mut DataStoreSession, request: DatasetWithdrawRequest, authenticated_actor: &str, ) -> Result<GovernedDeleteOutcome, AppError>

impl ScopedAppService<'static>

pub async fn list_catalogue_variables( &self, request: ListVariablesRequest, ) -> Result<VariableListResponse, AppError>

pub async fn get_catalogue_variable( &self, request: GetVariableRequest, ) -> Result<VariableDetailResponse, AppError>

pub async fn add_catalogue_variable( &self, request: AddVariableRequest, ) -> Result<VariableDetailResponse, AppError>

pub async fn update_catalogue_variable( &self, request: UpdateVariableRequest, ) -> Result<VariableDetailResponse, AppError>

pub async fn list_catalogue_vocabularies( &self, request: ListVocabulariesRequest, ) -> Result<VocabularyListResponse, AppError>

pub async fn get_catalogue_vocabulary( &self, request: GetVocabularyRequest, ) -> Result<VocabularyDetailResponse, AppError>

pub async fn add_catalogue_vocabulary( &self, request: AddVocabularyRequest, ) -> Result<VocabularyDetailResponse, AppError>

pub async fn list_catalogue_entities( &self, request: ListEntitiesRequest, ) -> Result<EntityListResponse, AppError>

pub async fn get_catalogue_entity( &self, request: GetEntityRequest, ) -> Result<EntityDetailResponse, AppError>

pub async fn add_catalogue_entity( &self, request: AddEntityRequest, ) -> Result<EntityDetailResponse, AppError>

pub async fn list_catalogue_relations( &self, request: ListRelationsRequest, ) -> Result<RelationListResponse, AppError>

pub async fn get_catalogue_relation( &self, request: GetRelationRequest, ) -> Result<RelationDetailResponse, AppError>

pub async fn add_catalogue_relation( &self, request: AddRelationRequest, ) -> Result<RelationDetailResponse, AppError>

pub async fn list_catalogue_transformations( &self, request: TransformationListRequest, ) -> Result<Vec<TransformationSummary>, AppError>

impl<'repository> ScopedAppService<'repository>

pub async fn ensure_study_entity_instance( &self, request: EnsureStudyEntityInstanceRequest, ) -> Result<StudyEntityInstanceRegistration, AppError>

pub async fn ensure_study_relation_instance( &self, request: EnsureStudyRelationInstanceRequest, ) -> Result<StudyRelationInstanceRegistration, AppError>

pub async fn record_transformation( &self, request: RecordTransformationRequest, ) -> Result<TransformationLineageRecord, AppError>

impl ScopedAppService<'static>

pub async fn admit_semantic_readback<'s>( session: &'s mut DataStoreSession, request: SemanticReadbackRequest, ) -> Result<SessionDisclosure<'s>, AppError>

Ticket 15 consumes this retained capability. All scope resolution and content projection remain in the application; transports receive bytes only after the usual admission and delivery evidence acknowledgements.

impl ScopedAppService<'static>

pub async fn ingest_upload( &self, session: &mut DataStoreSession, status: SessionStatusPayload, upload: UploadRequest, input: UploadInput, ) -> Result<Value, AppError>

Receives a path-free upload under retained Session authority. All output naming, classification and materialization decisions remain app-owned.

impl ScopedAppService<'static>

pub async fn plan_governed_semantic_delete( &self, request: SemanticDeleteRequest, authenticated_actor: &str, ) -> Result<SemanticDeletePlanningResult, AppError>

pub async fn execute_governed_semantic_delete( &self, request: SemanticDeleteRequest, authenticated_actor: &str, ) -> Result<GovernedSemanticDeleteOutcome, AppError>

impl ScopedAppService<'static>

pub async fn search_catalogue_variables( &self, request: SearchVariablesRequest, ) -> Result<(Vec<VariableSummary>, Option<String>), AppError>

pub async fn search_catalogue_entities( &self, request: SearchEntitiesRequest, ) -> Result<(Vec<EntitySummary>, Option<String>), AppError>

pub async fn search_catalogue_relations( &self, request: SearchRelationsRequest, ) -> Result<(Vec<RelationDefinitionSummary>, Option<String>), AppError>

impl ScopedAppService<'static>

pub async fn list_catalogue_tags( &self, _request: TagListRequest, ) -> Result<TagListResponse, AppError>

pub async fn get_catalogue_tags( &self, request: TagGetRequest, ) -> Result<TargetTagsResponse, AppError>

pub async fn set_catalogue_tags( &self, request: TagSetRequest, ) -> Result<TargetTagsResponse, AppError>

impl ScopedAppService<'static>

pub async fn derive_dataset_from_managed_datafile_tracked( &self, session: &mut DataStoreSession, request: DeriveDatasetFromManagedDataFileRequest, context: OperationContext, submission: OperationSubmission, notify: impl FnOnce(OperationSummary) + Send + 'static, ) -> Result<StartResult<DatasetMaterializationResponse>, ProtocolError>

Executes in the caller’s worker, notifying only after durable acceptance.

pub async fn get_operation( &self, inspection: &OperationControl, owner: &str, operation: &OperationRef, events: Option<&PageRequest>, ) -> Result<OperationDetail, ProtocolError>

pub async fn get_operation_result( &self, inspection: &OperationControl, owner: &str, operation: &OperationRef, ) -> Result<OperationResult, ProtocolError>

impl ScopedAppService<'static>

pub async fn resolve_session_study( &self, datastore_id: Uuid, explicit: Option<StudySelector>, current: Option<ObjectRef>, ) -> Result<ObjectRef, ProtocolError>

Captures an explicit Study or a previously observed Session default using this operation’s authenticated metadata capability. Never falls back after an explicit selector fails.

pub async fn resolve_study_context( &self, datastore_id: Uuid, study: ObjectSelector, domain: Option<ObjectSelector>, ) -> Result<(ObjectRef, String), AppError>

Resolves scope and current authority through the same Study resolver used by catalogue workflows. Explicit constraints never consume a default.

impl<'repository> ScopedAppService<'repository>

pub fn new(repositories: ScopedAppRepositories<'repository>) -> Self

pub async fn get_asset( &self, request: GetAssetRequest, ) -> Result<AssetVersionCatalog, AppError>

impl ScopedAppService<'_>

pub async fn register_vocabulary( &self, request: RegisterVocabularyRequest, ) -> Result<RegisteredVocabulary, AppError>

impl ScopedAppService<'static>

pub fn from_datastore_session( session: &DataStoreSession, ) -> Result<Self, AppError>

pub async fn list_session_domains_observed( context: &CorrelationContext, session: &DataStoreSession, request: ListDomainsRequest, ) -> Result<DomainListResult, AppError>

Lists Domains using the retained Session capability and request-scoped observation.

pub async fn open_configured_datastore_session<R: DatastoreSecretResolver>( &self, request: OpenConfiguredDatastoreRequest, resolver: &R, ) -> Result<DataStoreSession, AppError>

Opens one selected Datastore from already-resolved configuration and Secret capabilities; this workflow performs no loading or environment lookup.

pub async fn datastore_content_counts( &self, ) -> Result<DatastoreContentCounts, AppError>

pub async fn file_to_dataset( &self, session: &mut DataStoreSession, request: FileToDatasetRequest, ) -> Result<DatasetMaterialization, AppError>

pub async fn derive_dataset_from_managed_datafile( &self, session: &mut DataStoreSession, request: DeriveDatasetFromManagedDataFileRequest, ) -> Result<DerivedManagedDataFileDataset, AppError>

pub async fn ingest_dataset_file( &self, session: &mut DataStoreSession, request: IngestDatasetFileRequest, ) -> Result<IngestedDatasetFile, AppError>

pub async fn ingest_file( &self, request: IngestFileRequest, ) -> Result<IngestedFileAsset, AppError>

pub async fn ingest_datafile( &self, session: &DataStoreSession, request: IngestDataFileRequest, ) -> Result<DataFileIngestResult, AppError>

Ingests adapter-provided content through one Session-scoped workflow.

pub async fn ingest_file_for_session( &self, session: &DataStoreSession, request: IngestFileRequest, ) -> Result<IngestedFileAsset, AppError>

pub async fn ingest_redcap_offline( &self, session: &mut DataStoreSession, request: OfflineRedcapIngestRequest, ) -> Result<RedcapIngestResult, AppError>

pub async fn open_duckdb_source( &self, request: OpenDuckDbSourceRequest, ) -> Result<SqlSourceConnection, AppError>

pub async fn open_sqlite_source( &self, request: OpenSqliteSourceRequest, ) -> Result<SqlSourceConnection, AppError>

pub async fn open_postgres_source( &self, request: OpenPostgresSourceRequest, ) -> Result<SqlSourceConnection, AppError>

pub async fn open_mssql_source( &self, request: OpenMsSqlSourceRequest, ) -> Result<SqlSourceConnection, AppError>

pub async fn analyze_sql_source_metadata( &self, source: &mut SqlSourceConnection, request: AnalyzeSqlSourceRequest, ) -> Result<SqlSourceAnalysis, AppError>

pub async fn sql_to_dataset( &self, session: &mut DataStoreSession, source: &mut SqlSourceConnection, request: SqlToDatasetRequest, ) -> Result<DatasetMaterialization, AppError>

pub async fn transform_dataset_with_lake_sql( &self, session: &mut DataStoreSession, request: DatasetSqlTransformRequest, ) -> Result<DatasetMaterialization, AppError>

pub async fn export_dataset( &self, session: &mut DataStoreSession, request: ExportDatasetRequest, ) -> Result<ExportedDataset, AppError>

pub async fn export_dataset_to_path( &self, session: &mut DataStoreSession, request: ExportDatasetToPathRequest, ) -> Result<ExportedDataset, AppError>

pub async fn export_datafile( &self, session: &DataStoreSession, request: ExportDataFileRequest, ) -> Result<ExportedDataFile, AppError>

pub async fn export_study_datafile( &self, session: &DataStoreSession, request: ExportStudyDataFileRequest, ) -> Result<ExportedDataFile, AppError>

pub async fn register_domain_study( &self, request: RegisterDomainStudyRequest, ) -> Result<StudyRegistration, AppError>

pub async fn register_dataset_variables( &self, request: RegisterDatasetVariablesRequest, ) -> Result<Vec<RegisteredDatasetVariable>, AppError>

pub async fn register_vocabulary_mapping( &self, request: RegisterVocabularyMappingRequest, ) -> Result<VocabularyMappingDetail, AppError>

pub async fn list_vocabulary_mappings( &self, request: ListVocabularyMappingsRequest, ) -> Result<Vec<VocabularyMappingDetail>, AppError>

pub async fn vocabulary_mapping_summary( &self, request: VocabularyMappingSummaryRequest, ) -> Result<VocabularyMappingSummary, AppError>

pub async fn register_variable( &self, request: RegisterVariableRequest, ) -> Result<RegisteredVariable, AppError>

pub async fn list_variables( &self, request: ListVariablesRequest, ) -> Result<Vec<RegisteredVariable>, AppError>

pub async fn search_variables( &self, request: SearchVariablesRequest, ) -> Result<VariableSearchResult, AppError>

pub async fn get_variable( &self, request: GetVariableRequest, ) -> Result<Option<RegisteredVariable>, AppError>

pub async fn add_variable( &self, request: AddVariableRequest, ) -> Result<RegisteredVariable, AppError>

pub async fn update_variable( &self, request: UpdateVariableRequest, ) -> Result<RegisteredVariable, AppError>

pub async fn delete_variable( &self, request: GetVariableRequest, ) -> Result<(), AppError>

pub async fn list_vocabularies( &self, request: ListVocabulariesRequest, ) -> Result<Vec<RegisteredVocabulary>, AppError>

pub async fn get_vocabulary( &self, request: GetVocabularyRequest, ) -> Result<Option<RegisteredVocabulary>, AppError>

pub async fn add_vocabulary( &self, request: AddVocabularyRequest, ) -> Result<RegisteredVocabulary, AppError>

pub async fn delete_vocabulary( &self, request: GetVocabularyRequest, ) -> Result<(), AppError>

pub async fn plan_semantic_delete( &self, request: PlanSemanticDeleteRequest, ) -> Result<SemanticDeletePlanningResult, AppError>

pub async fn execute_semantic_delete( &self, request: ExecuteSemanticDeleteRequest, ) -> Result<ExecuteSemanticDeleteResult, AppError>

pub async fn get_dataset_variables( &self, request: GetDatasetVariablesRequest, ) -> Result<DatasetVariablesMetadata, AppError>

pub async fn list_tags(&self) -> Result<Vec<TagRecord>, AppError>

pub async fn get_tags( &self, request: GetTagsRequest, ) -> Result<TargetTags, AppError>

pub async fn set_tags( &self, request: SetTagsRequest, ) -> Result<TargetTags, AppError>

pub async fn register_entity( &self, request: RegisterEntityRequest, ) -> Result<EntityRecord, AppError>

pub async fn register_entity_relation( &self, request: RegisterEntityRelationRequest, ) -> Result<EntityRelationRecord, AppError>

pub async fn list_entities( &self, request: ListEntitiesRequest, ) -> Result<Vec<EntityRecord>, AppError>

pub async fn search_entities( &self, request: SearchEntitiesRequest, ) -> Result<EntitySearchResult, AppError>

pub async fn search_entity_relations( &self, request: SearchRelationsRequest, ) -> Result<RelationSearchResult, AppError>

pub async fn get_entity( &self, request: GetEntityRequest, ) -> Result<Option<EntityRecord>, AppError>

pub async fn add_entity( &self, request: AddEntityRequest, ) -> Result<EntityRecord, AppError>

pub async fn list_entity_relations( &self, request: ListEntityRelationsRequest, ) -> Result<Vec<EntityRelationRecord>, AppError>

pub async fn get_entity_relation( &self, request: GetEntityRelationRequest, ) -> Result<Option<EntityRelationRecord>, AppError>

pub async fn add_entity_relation( &self, request: AddEntityRelationRequest, ) -> Result<EntityRelationRecord, AppError>

pub async fn get_entity_instance( &self, request: GetEntityInstanceRequest, ) -> Result<Option<EntityInstanceRecord>, AppError>

pub async fn list_entity_instances( &self, request: ListEntityInstancesRequest, ) -> Result<Vec<EntityInstanceRecord>, AppError>

pub async fn add_entity_instance( &self, request: AddEntityInstanceRequest, ) -> Result<EntityInstanceRecord, AppError>

pub async fn add_study_entity_instance_mapping( &self, request: AddStudyEntityInstanceMappingRequest, ) -> Result<EntityInstanceMapping, AppError>

pub async fn get_study_entity_instance_mapping( &self, request: GetStudyEntityInstanceMappingRequest, ) -> Result<Option<EntityInstanceMapping>, AppError>

pub async fn list_study_entity_instance_mappings( &self, request: ListStudyEntityInstanceMappingsRequest, ) -> Result<EntityInstanceMappingList, AppError>

pub async fn add_entity_asset_link( &self, request: AddEntityAssetLinkRequest, ) -> Result<AssetVersionEntityRecord, AppError>

pub async fn list_entity_asset_links( &self, request: ListEntityAssetLinksRequest, ) -> Result<EntityAssetLinkList, AppError>

pub async fn add_entity_dataset_link( &self, request: AddEntityDatasetLinkRequest, ) -> Result<DatasetVersionEntityRecord, AppError>

pub async fn list_entity_instance_datasets( &self, request: ListEntityInstanceDatasetsRequest, ) -> Result<EntityDatasetLinkList, AppError>

pub async fn get_entity_dataset_link( &self, request: GetEntityDatasetLinkRequest, ) -> Result<Option<EntityDatasetLinkReadback>, AppError>

pub async fn list_entity_dataset_links( &self, request: ListEntityDatasetLinksRequest, ) -> Result<EntityDatasetLinkList, AppError>

pub async fn ensure_entity_instances_from_dataset( &self, session: &DataStoreSession, request: EnsureEntityInstancesFromDatasetRequest, ) -> Result<EntityInstanceDatasetBatchResult, AppError>

pub async fn ensure_relation_instances_from_dataset( &self, session: &DataStoreSession, request: EnsureRelationInstancesFromDatasetRequest, ) -> Result<RelationInstanceDatasetBatchResult, AppError>

pub async fn get_relation_instance( &self, request: GetRelationInstanceRequest, ) -> Result<Option<RelationInstanceRecord>, AppError>

pub async fn list_relation_instances( &self, request: ListRelationInstancesRequest, ) -> Result<Vec<RelationInstanceRecord>, AppError>

pub async fn add_relation_instance( &self, request: AddRelationInstanceRequest, ) -> Result<RelationInstanceRecord, AppError>

pub async fn add_study_relation_instance_mapping( &self, request: AddStudyRelationInstanceMappingRequest, ) -> Result<RelationInstanceMapping, AppError>

pub async fn get_study_relation_instance_mapping( &self, request: GetStudyRelationInstanceMappingRequest, ) -> Result<Option<RelationInstanceMapping>, AppError>

pub async fn list_study_relation_instance_mappings( &self, request: ListStudyRelationInstanceMappingsRequest, ) -> Result<RelationInstanceMappingList, AppError>

pub async fn add_relation_asset_link( &self, request: AddRelationAssetLinkRequest, ) -> Result<AssetVersionRelationInstanceRecord, AppError>

pub async fn list_relation_asset_links( &self, request: ListRelationAssetLinksRequest, ) -> Result<RelationAssetLinkList, AppError>

pub async fn add_relation_dataset_link( &self, request: AddRelationDatasetLinkRequest, ) -> Result<DatasetVersionRelationInstanceRecord, AppError>

pub async fn get_relation_dataset_link( &self, request: GetRelationDatasetLinkRequest, ) -> Result<Option<RelationDatasetLinkReadback>, AppError>

pub async fn list_relation_dataset_links( &self, request: ListRelationDatasetLinksRequest, ) -> Result<RelationDatasetLinkList, AppError>

pub async fn link_dataset_version_entities( &self, request: LinkDatasetVersionEntitiesRequest, ) -> Result<(), AppError>

pub async fn link_dataset_version_relation_instances( &self, request: LinkDatasetVersionRelationInstancesRequest, ) -> Result<(), AppError>

pub async fn list_study_transformations( &self, request: ListStudyTransformationsRequest, ) -> Result<Vec<TransformationSummary>, AppError>

pub async fn register_domain( &self, request: RegisterDomainRequest, ) -> Result<DomainRecord, AppError>

pub async fn list_domains( &self, _request: ListDomainsRequest, ) -> Result<DomainListResult, AppError>

pub async fn get_domain( &self, request: GetDomainRequest, ) -> Result<Option<DomainRecord>, AppError>

pub async fn add_domain( &self, request: AddDomainRequest, ) -> Result<DomainAddResult, AppError>

pub async fn register_new_domain( &self, request: RegisterNewDomainRequest, ) -> Result<DomainRecord, AppError>

pub async fn list_studies( &self, _request: ListStudiesRequest, ) -> Result<StudyListResult, AppError>

pub async fn search_studies( &self, request: SearchStudiesRequest, ) -> Result<StudySearchResult, AppError>

pub async fn search_datasets( &self, request: SearchDatasetsRequest, ) -> Result<DatasetSearchResult, AppError>

pub async fn search_datafiles( &self, request: SearchDataFilesRequest, ) -> Result<DataFileSearchResult, AppError>

pub async fn get_study( &self, request: GetStudyRequest, ) -> Result<Option<StudyRegistration>, AppError>

pub async fn add_study( &self, request: AddStudyRequest, ) -> Result<StudyAddResult, AppError>

pub async fn add_study_domain( &self, request: AddStudyDomainRequest, ) -> Result<StudyRegistration, AppError>

pub async fn register_study( &self, request: RegisterStudyRequest, ) -> Result<StudyRegistration, AppError>

pub async fn register_new_study( &self, request: RegisterNewStudyRequest, ) -> Result<StudyRegistration, AppError>

pub async fn get_study_registration( &self, request: GetStudyRegistrationRequest, ) -> Result<StudyRegistration, AppError>

pub async fn list_study_access_grants( &self, request: ListStudyAccessGrantsRequest, ) -> Result<StudyAccessGrantList, AppError>

pub async fn grant_study_access( &self, request: GrantStudyAccessRequest, ) -> Result<StudyAccessGrant, AppError>

pub async fn revoke_study_access( &self, request: RevokeStudyAccessRequest, ) -> Result<StudyAccessRevocation, AppError>

pub async fn list_study_custodians( &self, request: ListStudyCustodiansRequest, ) -> Result<StudyCustodianList, AppError>

pub async fn add_delegate_custodian( &self, request: AddDelegateCustodianRequest, ) -> Result<StudyCustodian, AppError>

pub async fn transfer_primary_custodianship( &self, request: TransferPrimaryCustodianshipRequest, ) -> Result<StudyPrimaryCustodianshipTransfer, AppError>

pub async fn remove_delegate_custodian( &self, request: RemoveDelegateCustodianRequest, ) -> Result<StudyDelegateCustodianRemoval, AppError>

pub async fn list_study_duo_restrictions( &self, request: ListStudyDuoRestrictionsRequest, ) -> Result<StudyDuoRestrictionList, AppError>

pub async fn replace_study_duo_restrictions( &self, request: ReplaceStudyDuoRestrictionsRequest, ) -> Result<StudyDuoRestrictionReplacement, AppError>

pub async fn list_asset_version_duo_restrictions( &self, request: ListAssetVersionDuoRestrictionsRequest, ) -> Result<AssetVersionDuoRestrictionList, AppError>

pub async fn list_effective_asset_version_duo_restrictions( &self, request: ListEffectiveAssetVersionDuoRestrictionsRequest, ) -> Result<EffectiveAssetVersionDuoRestrictionList, AppError>

pub async fn replace_asset_version_duo_restrictions( &self, request: ReplaceAssetVersionDuoRestrictionsRequest, ) -> Result<AssetVersionDuoRestrictionReplacement, AppError>

pub async fn clear_asset_version_duo_restrictions( &self, request: ClearAssetVersionDuoRestrictionsRequest, ) -> Result<AssetVersionDuoRestrictionClear, AppError>

pub async fn create_asset( &self, request: CreateAssetRequest, ) -> Result<AssetVersionCatalog, AppError>

pub async fn create_new_asset( &self, request: CreateNewAssetRequest, ) -> Result<AssetVersionCatalog, AppError>

pub async fn create_asset_version( &self, request: CreateAssetVersionRequest, ) -> Result<AssetVersionCatalog, AppError>

pub async fn create_new_asset_version( &self, request: CreateNewAssetVersionRequest, ) -> Result<AssetVersionCatalog, AppError>

pub async fn list_study_assets( &self, request: ListStudyAssetsRequest, ) -> Result<Vec<AssetRecord>, AppError>

pub async fn list_study_datasets( &self, request: ListStudyDatasetsRequest, ) -> Result<StudyDatasetList, AppError>

pub async fn get_study_dataset( &self, request: GetStudyDatasetRequest, ) -> Result<Option<StudyDatasetMetadata>, AppError>

pub async fn get_dataset_metadata_by_id( &self, request: DatasetMetadataByIdRequest, ) -> Result<StudyDatasetMetadata, AppError>

pub async fn read_dataset_metadata( &self, request: ReadDatasetMetadataRequest, ) -> Result<Option<DatasetMetadataResult>, AppError>

pub async fn preview_study_dataset( &self, session: &DataStoreSession, request: PreviewStudyDatasetRequest, ) -> Result<Option<DatasetPreview>, AppError>

pub async fn preview_dataset_by_id( &self, session: &DataStoreSession, request: PreviewDatasetByIdRequest, ) -> Result<DatasetPreview, AppError>

pub async fn withdraw_dataset_version( &self, session: Option<&mut DataStoreSession>, request: WithdrawDatasetVersionRequest, ) -> Result<WithdrawDatasetVersionResult, AppError>

pub async fn plan_archive_delete( &self, request: PlanArchiveDeleteRequest, ) -> Result<ArchiveDeletePlanningResult, AppError>

pub async fn delete_dataset_asset_version( &self, session: &mut DataStoreSession, request: DeleteDatasetAssetVersionRequest, ) -> Result<DeleteDatasetAssetVersionResult, AppError>

pub async fn delete_datafile_asset_version( &self, session: &mut DataStoreSession, request: DeleteDataFileAssetVersionRequest, ) -> Result<DeleteDataFileAssetVersionResult, AppError>

pub async fn delete_asset( &self, session: &mut DataStoreSession, request: DeleteAssetRequest, ) -> Result<DeleteAssetResult, AppError>

pub async fn delete_archived_study( &self, session: &mut DataStoreSession, request: DeleteArchivedStudyRequest, ) -> Result<DeleteArchivedStudyResult, AppError>

pub async fn plan_or_prepare_study_archive_for_deletion( &self, request: PrepareStudyArchiveForDeletionRequest, ) -> Result<PreparedStudyArchiveForDeletionResult, AppError>

pub async fn archive_study_for_deletion( &self, session: &mut DataStoreSession, request: ArchiveStudyForDeletionRequest, ) -> Result<ArchiveStudyForDeletionResult, AppError>

pub async fn list_study_datafiles( &self, request: ListStudyDataFilesRequest, ) -> Result<Vec<StudyDataFileEntry>, AppError>

pub async fn list_datafiles( &self, request: ListDataFilesRequest, ) -> Result<DataFileListResult, AppError>

Resolves a public Study selector and returns its governed Datafile catalogue.

pub async fn get_datafile_metadata( &self, request: DataFileMetadataRequest, ) -> Result<DataFileMetadata, AppError>

pub async fn get_datafile_metadata_by_id( &self, request: DataFileMetadataByIdRequest, ) -> Result<DataFileMetadata, AppError>

pub async fn record_export( &self, request: RecordExportRequest, ) -> Result<TransformationLineageRecord, AppError>

pub async fn transform_assets( &self, request: TransformAssetsRequest, ) -> Result<TransformationLineageRecord, AppError>

pub fn new_noop() -> Self

Trait Implementations

impl<'repository> Clone for ScopedAppService<'repository>

fn clone(&self) -> ScopedAppService<'repository>

Returns a duplicate of the value.

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

Performs copy-assignment from source.