Architecture Map
Relevant source files
The following files were used as context for generating this wiki page:
Introduction
The flext-target-oracle-oic project is a specialized Singer Target designed for loading data into Oracle Integration Cloud (OIC). Built upon the FLEXT framework, it leverages a modular architecture that integrates flext-core, flext-meltano, and flext-oracle-oic to provide a typed, high-performance integration layer for OIC resources such as connections, integrations, packages, and lookups.
Sources: README.md:1-12, pyproject.toml:23-38, src/flext_target_oracle_oic/target.py:35-42
Component Hierarchy
The system is organized into distinct namespaces that separate domain models, message processing logic, and utility functions. The core entry point is the FlextTargetOracleOic class, which orchestrates various stream-specific sinks.
System Class Diagram
The following diagram illustrates the relationship between the main target class, its specialized sinks, and the underlying utility and model namespaces.
Data Flow and Message Processing
Data processing follows the Singer protocol where records are received and routed to specific sinks based on the stream name. The FlextTargetOracleOic orchestrator resolves the appropriate sink class at runtime.
Record Processing Flow
- Target Initialization: The target sets up resources and validates configuration.
- Stream Routing: Incoming Singer messages are identified by stream name.
- Sink Activation: The corresponding sink (e.g.,
ConnectionsSink) receives the record. - Validation/Transformation: Records are validated against Pydantic models in
FlextTargetOracleOicModels.
Authentication and Security
The project implements a dedicated OAuth2 Authenticator specifically for Oracle Integration Cloud, handling token acquisition and header injection.
OAuth2 Authentication Sequence
The Authenticator class in utilities.py manages the lifecycle of the access token, using client credentials to authenticate against the OIC identity provider.
Domain Models
The FlextTargetOracleOicModels class provides Pydantic-based data structures for all supported OIC entities. These models ensure runtime type safety and data integrity before payloads are transmitted to the OIC API.
| Model | Description | Key Fields |
|---|---|---|
OICConnection | Metadata for OIC adapter connections | id, name, adapter_type, properties |
OICIntegration | Definition for OIC integration flows | id, name, version, pattern |
OICPackage | Container for grouping OIC resources | id, name, version |
OICLookup | Static data mapping tables | name, columns, rows |
OICProject | High-level project containers | id, name |
Sources: src/flext_target_oracle_oic/models.py:18-72
Infrastructure and Module Map
The project utilizes a "lazy export" pattern to optimize startup performance. This is managed via _exports_lazy_part_01.py and the main __init__.py, which mapping internal modules to public-facing aliases.
Module Relationship Map
The following diagram shows the internal structure of the flext_target_oracle_oic package.
Conclusion
The architecture of flext-target-oracle-oic centers on a robust, model-driven approach to data loading. By separating authentication, domain modeling, and stream-specific sink logic, the system provides a maintainable and scalable foundation for synchronizing enterprise data with Oracle Integration Cloud.