Gabriel Kaszewski
838ed9a3f8
- Both binaries connect to NATS on startup, ensure JetStream stream - EventPublisherAdapter<NatsTransport> replaces LogEventPublisher - nats_url config with default nats://localhost:4222 - Deleted bootstrap's LogEventPublisher (no longer needed)
301 lines
11 KiB
Rust
301 lines
11 KiB
Rust
use anyhow::Result;
|
|
use axum::Router;
|
|
use axum::http::HeaderValue;
|
|
use std::sync::Arc;
|
|
use tower_http::{
|
|
cors::{Any, CorsLayer},
|
|
trace::TraceLayer,
|
|
};
|
|
|
|
use adapters_auth::{BcryptPasswordHasher, JwtTokenIssuer};
|
|
|
|
use adapters_postgres::{
|
|
PostgresAlbumRepository, PostgresAssetMetadataRepository, PostgresAssetRepository,
|
|
PostgresDuplicateRepository, PostgresIngestSessionRepository, PostgresJobBatchRepository,
|
|
PostgresJobRepository, PostgresLibraryPathRepository, PostgresPipelineRepository,
|
|
PostgresPluginRepository, PostgresQuotaRepository, PostgresShareRepository,
|
|
PostgresSidecarRepository, PostgresStorageVolumeRepository, PostgresTagRepository,
|
|
PostgresUsageLedgerRepository, PostgresUserRepository, PostgresVisibilityFilterRepository,
|
|
connect, run_migrations,
|
|
};
|
|
|
|
use adapters_storage::LocalFileStorage;
|
|
|
|
use application::{
|
|
catalog::{
|
|
GetAssetHandler, GetTimelineHandler, ReadAssetFileHandler, RegisterAssetHandler,
|
|
UpdateMetadataHandler,
|
|
},
|
|
identity::{GetProfileHandler, LoginUserHandler, RegisterUserHandler},
|
|
organization::{
|
|
CreateAlbumHandler, GetAlbumHandler, ManageAlbumEntriesHandler, TagAssetHandler,
|
|
},
|
|
processing::{
|
|
CompleteJobHandler, ConfigurePipelineHandler, EnqueueJobHandler, FailJobHandler,
|
|
ManagePluginHandler, ReportBatchProgressHandler, StartJobHandler,
|
|
},
|
|
sharing::{
|
|
AccessSharedResourceHandler, GenerateShareLinkHandler, RevokeShareHandler,
|
|
ShareResourceHandler,
|
|
},
|
|
sidecar::{
|
|
DetectExternalChangesHandler, ExportSidecarHandler, FullExportHandler, FullImportHandler,
|
|
ImportSidecarHandler, ResolveConflictHandler,
|
|
},
|
|
storage::{
|
|
CheckQuotaHandler, IngestAssetHandler, RegisterLibraryPathHandler, RegisterVolumeHandler,
|
|
},
|
|
};
|
|
use presentation::{
|
|
routes::app_router,
|
|
state::{
|
|
AppState, CatalogHandlers, IdentityHandlers, OrganizationHandlers, ProcessingHandlers,
|
|
SharingHandlers, SidecarHandlers, StorageHandlers,
|
|
},
|
|
};
|
|
|
|
use crate::config::Config;
|
|
use crate::log_sidecar_writer::LogSidecarWriter;
|
|
|
|
pub async fn build_app(config: &Config) -> Result<Router> {
|
|
let pool = connect(&config.database_url).await?;
|
|
run_migrations(&pool).await?;
|
|
|
|
let nats_client = async_nats::connect(&config.nats_url).await?;
|
|
adapters_nats::ensure_stream(&nats_client).await?;
|
|
|
|
// Identity
|
|
let user_repo = Arc::new(PostgresUserRepository::new(pool.clone()));
|
|
let hasher = Arc::new(BcryptPasswordHasher);
|
|
let issuer = Arc::new(JwtTokenIssuer::new(&config.jwt_secret));
|
|
|
|
let register_handler = Arc::new(RegisterUserHandler::new(user_repo.clone(), hasher.clone()));
|
|
let login_handler = Arc::new(LoginUserHandler::new(
|
|
user_repo.clone(),
|
|
hasher,
|
|
issuer.clone(),
|
|
));
|
|
let get_profile_handler = Arc::new(GetProfileHandler::new(user_repo));
|
|
|
|
// Repos
|
|
let album_repo = Arc::new(PostgresAlbumRepository::new(pool.clone()));
|
|
let asset_repo = Arc::new(PostgresAssetRepository::new(pool.clone()));
|
|
let metadata_repo = Arc::new(PostgresAssetMetadataRepository::new(pool.clone()));
|
|
let volume_repo = Arc::new(PostgresStorageVolumeRepository::new(pool.clone()));
|
|
let path_repo = Arc::new(PostgresLibraryPathRepository::new(pool.clone()));
|
|
let session_repo = Arc::new(PostgresIngestSessionRepository::new(pool.clone()));
|
|
let quota_repo = Arc::new(PostgresQuotaRepository::new(pool.clone()));
|
|
let ledger_repo = Arc::new(PostgresUsageLedgerRepository::new(pool.clone()));
|
|
let tag_repo = Arc::new(PostgresTagRepository::new(pool.clone()));
|
|
let duplicate_repo = Arc::new(PostgresDuplicateRepository::new(pool.clone()));
|
|
let sidecar_repo = Arc::new(PostgresSidecarRepository::new(pool.clone()));
|
|
let job_repo = Arc::new(PostgresJobRepository::new(pool.clone()));
|
|
let batch_repo = Arc::new(PostgresJobBatchRepository::new(pool.clone()));
|
|
let plugin_repo = Arc::new(PostgresPluginRepository::new(pool.clone()));
|
|
let pipeline_repo = Arc::new(PostgresPipelineRepository::new(pool.clone()));
|
|
let transport = adapters_nats::NatsTransport::new(nats_client);
|
|
let event_publisher: Arc<dyn domain::ports::EventPublisher> =
|
|
Arc::new(event_transport::EventPublisherAdapter::new(transport));
|
|
let sidecar_writer: Arc<LogSidecarWriter> = Arc::new(LogSidecarWriter);
|
|
|
|
// File storage
|
|
let storage_path = std::env::var("STORAGE_PATH").unwrap_or_else(|_| "./data/media".to_string());
|
|
let file_storage: Arc<LocalFileStorage> = Arc::new(LocalFileStorage::new(&storage_path));
|
|
|
|
// Album handlers
|
|
let create_album_handler = Arc::new(CreateAlbumHandler::new(album_repo.clone()));
|
|
let get_album_handler = Arc::new(GetAlbumHandler::new(album_repo.clone()));
|
|
let manage_album_entries_handler = Arc::new(ManageAlbumEntriesHandler::new(album_repo));
|
|
|
|
// Asset handlers
|
|
let ingest_asset_handler = Arc::new(IngestAssetHandler::new(
|
|
session_repo,
|
|
path_repo.clone(),
|
|
quota_repo.clone(),
|
|
ledger_repo.clone(),
|
|
asset_repo.clone(),
|
|
file_storage.clone(),
|
|
event_publisher.clone(),
|
|
));
|
|
let get_asset_handler = Arc::new(GetAssetHandler::new(
|
|
asset_repo.clone(),
|
|
metadata_repo.clone(),
|
|
));
|
|
let get_timeline_handler = Arc::new(GetTimelineHandler::new(
|
|
asset_repo.clone(),
|
|
metadata_repo.clone(),
|
|
));
|
|
let update_metadata_handler = Arc::new(UpdateMetadataHandler::new(
|
|
asset_repo.clone(),
|
|
metadata_repo.clone(),
|
|
event_publisher.clone(),
|
|
));
|
|
let read_asset_file_handler =
|
|
Arc::new(ReadAssetFileHandler::new(asset_repo.clone(), file_storage));
|
|
|
|
// Register asset handler
|
|
let register_asset_handler = Arc::new(RegisterAssetHandler::new(
|
|
asset_repo.clone(),
|
|
duplicate_repo,
|
|
event_publisher.clone(),
|
|
));
|
|
|
|
// Tag handler
|
|
let tag_asset_handler = Arc::new(TagAssetHandler::new(asset_repo.clone(), tag_repo));
|
|
|
|
// Check quota handler
|
|
let check_quota_handler = Arc::new(CheckQuotaHandler::new(quota_repo, ledger_repo));
|
|
|
|
// Sidecar handlers
|
|
let export_sidecar_handler = Arc::new(ExportSidecarHandler::new(
|
|
metadata_repo.clone(),
|
|
sidecar_repo.clone(),
|
|
sidecar_writer.clone(),
|
|
));
|
|
let detect_changes_handler = Arc::new(DetectExternalChangesHandler::new(
|
|
sidecar_repo.clone(),
|
|
sidecar_writer.clone(),
|
|
));
|
|
let import_sidecar_handler = Arc::new(ImportSidecarHandler::new(
|
|
sidecar_repo.clone(),
|
|
sidecar_writer.clone(),
|
|
metadata_repo.clone(),
|
|
));
|
|
let resolve_conflict_handler = Arc::new(ResolveConflictHandler::new(
|
|
sidecar_repo.clone(),
|
|
sidecar_writer.clone(),
|
|
metadata_repo.clone(),
|
|
));
|
|
let full_export_handler = Arc::new(FullExportHandler::new(
|
|
asset_repo.clone(),
|
|
metadata_repo.clone(),
|
|
sidecar_repo.clone(),
|
|
sidecar_writer.clone(),
|
|
));
|
|
let full_import_handler = Arc::new(FullImportHandler::new(
|
|
asset_repo,
|
|
metadata_repo,
|
|
sidecar_repo,
|
|
sidecar_writer,
|
|
));
|
|
|
|
// Processing handlers
|
|
let enqueue_job_handler = Arc::new(EnqueueJobHandler::new(
|
|
job_repo.clone(),
|
|
event_publisher.clone(),
|
|
));
|
|
let start_job_handler = Arc::new(StartJobHandler::new(job_repo.clone()));
|
|
let complete_job_handler = Arc::new(CompleteJobHandler::new(
|
|
job_repo.clone(),
|
|
batch_repo.clone(),
|
|
event_publisher.clone(),
|
|
));
|
|
let fail_job_handler = Arc::new(FailJobHandler::new(
|
|
job_repo.clone(),
|
|
batch_repo.clone(),
|
|
event_publisher.clone(),
|
|
));
|
|
let batch_progress_handler = Arc::new(ReportBatchProgressHandler::new(batch_repo, job_repo));
|
|
let manage_plugin_handler = Arc::new(ManagePluginHandler::new(plugin_repo.clone()));
|
|
let configure_pipeline_handler =
|
|
Arc::new(ConfigurePipelineHandler::new(pipeline_repo, plugin_repo));
|
|
|
|
// Sharing repos & handlers
|
|
let share_repo = Arc::new(PostgresShareRepository::new(pool.clone()));
|
|
let _visibility_filter_repo = Arc::new(PostgresVisibilityFilterRepository::new(pool));
|
|
|
|
let share_resource_handler = Arc::new(ShareResourceHandler::new(
|
|
share_repo.clone(),
|
|
event_publisher.clone(),
|
|
));
|
|
let generate_link_handler = Arc::new(GenerateShareLinkHandler::new(share_repo.clone()));
|
|
let revoke_handler = Arc::new(RevokeShareHandler::new(share_repo.clone(), event_publisher));
|
|
let access_handler = Arc::new(AccessSharedResourceHandler::new(share_repo));
|
|
|
|
// Storage handlers
|
|
let register_volume_handler = Arc::new(RegisterVolumeHandler::new(volume_repo.clone()));
|
|
let register_library_path_handler =
|
|
Arc::new(RegisterLibraryPathHandler::new(volume_repo, path_repo));
|
|
|
|
let identity = IdentityHandlers {
|
|
register: register_handler,
|
|
login: login_handler,
|
|
get_profile: get_profile_handler,
|
|
};
|
|
|
|
let catalog = CatalogHandlers {
|
|
ingest_asset: ingest_asset_handler,
|
|
get_asset: get_asset_handler,
|
|
get_timeline: get_timeline_handler,
|
|
update_metadata: update_metadata_handler,
|
|
read_asset_file: read_asset_file_handler,
|
|
register_asset: register_asset_handler,
|
|
};
|
|
|
|
let organization = OrganizationHandlers {
|
|
create_album: create_album_handler,
|
|
get_album: get_album_handler,
|
|
manage_album_entries: manage_album_entries_handler,
|
|
tag_asset: tag_asset_handler,
|
|
};
|
|
|
|
let storage_handlers = StorageHandlers {
|
|
register_volume: register_volume_handler,
|
|
register_library_path: register_library_path_handler,
|
|
check_quota: check_quota_handler,
|
|
};
|
|
|
|
let sidecar = SidecarHandlers {
|
|
export: export_sidecar_handler,
|
|
detect_changes: detect_changes_handler,
|
|
import: import_sidecar_handler,
|
|
resolve: resolve_conflict_handler,
|
|
full_export: full_export_handler,
|
|
full_import: full_import_handler,
|
|
};
|
|
|
|
let processing = ProcessingHandlers {
|
|
enqueue_job: enqueue_job_handler,
|
|
start_job: start_job_handler,
|
|
complete_job: complete_job_handler,
|
|
fail_job: fail_job_handler,
|
|
batch_progress: batch_progress_handler,
|
|
manage_plugin: manage_plugin_handler,
|
|
configure_pipeline: configure_pipeline_handler,
|
|
};
|
|
|
|
let sharing = SharingHandlers {
|
|
share_resource: share_resource_handler,
|
|
generate_link: generate_link_handler,
|
|
revoke: revoke_handler,
|
|
access: access_handler,
|
|
};
|
|
|
|
let state = AppState {
|
|
identity,
|
|
catalog,
|
|
organization,
|
|
storage: storage_handlers,
|
|
sharing,
|
|
sidecar,
|
|
processing,
|
|
token_issuer: issuer,
|
|
};
|
|
|
|
let cors = CorsLayer::new()
|
|
.allow_origin(
|
|
config
|
|
.cors_allowed_origins
|
|
.iter()
|
|
.filter_map(|o| o.parse::<HeaderValue>().ok())
|
|
.collect::<Vec<_>>(),
|
|
)
|
|
.allow_methods(Any)
|
|
.allow_headers(Any);
|
|
|
|
Ok(app_router()
|
|
.with_state(state)
|
|
.layer(TraceLayer::new_for_http())
|
|
.layer(cors))
|
|
}
|