docs: target systems update

Author: dieppa

docs/flamingock-library-config/context-and-dependencies.md

@@ -53,15 +53,15 @@ MongoSyncTargetSystem mongoTarget = new MongoSyncTargetSystem("user-db")
     .withMongoClient(client);    // MongoDB-specific method
 ```
 
-**Generic methods** - All target systems (including DefaultTargetSystem) support generic dependency injection:
+**Generic methods** - All target systems (including NonTransactionalTargetSystem) support generic dependency injection:
 ```java
-DefaultTargetSystem kafkaTarget = new DefaultTargetSystem("events")
+NonTransactionalTargetSystem kafkaTarget = new NonTransactionalTargetSystem("events-id")
     .addDependency(kafkaProducer)
     .addDependency("notification-service", notificationService)
     .setProperty("batch.size", 1000);
 ```
 
-This flexibility allows DefaultTargetSystem to inject any dependencies needed for non-transactional systems, while specialized target systems provide convenience methods for their common dependencies.
+This flexibility allows NonTransactionalTargetSystem to inject any dependencies needed for non-transactional systems, while specialized target systems provide convenience methods for their common dependencies.
 
 ### Global dependencies
 

docs/frameworks/springboot-integration/enable-flamingock-setup.md

@@ -68,8 +68,8 @@ With automatic setup, Flamingock needs access to your target systems and (for Co
 Example target system bean registration:
 ```java
 @Bean
-public DefaultTargetSystem redisTargetSystem() {
-    return new DefaultTargetSystem("redis-cache");
+public NonTransactionalTargetSystem redisTargetSystem() {
+    return new NonTransactionalTargetSystem("redis-cache-id");
 }
 ```
 

docs/overview/quick-start.md

@@ -79,13 +79,32 @@ annotationProcessor("io.flamingock:flamingock-processor:$flamingockVersion")
 
 
 
-## 2. Define your first Changes
+## 2. Create target systems
 
-Each Change represents a single change.  
+Target systems represent the external systems Flamingock will apply your changes to.
+They are configured in the builder and shared across Changes.
+
+For our example:
+- A MySQL database (`mysql-inventory`)
+- An S3 bucket service (`aws-s3`)
+- A Kafka cluster (`kafka`)
+
+```java
+SqlTargetSystem sql = new SqlTargetSystem("mysql-inventory").withDatasource(ds);
+NonTransactionalTargetSystem s3 = new NonTransactionalTargetSystem("aws-s3-id");
+NonTransactionalTargetSystem kafka = new NonTransactionalTargetSystem("kafka-id");
+```
+
+See [Target systems](../target-systems/introduction.md) for more details.
+
+
+## 3. Define your first Changes
+
+Each Change represents a single change.
 For our example, we'll define three:
 
 - **MySQL**: Add a column `category` to products
-- **S3**: Create a `product-images` bucket  
+- **S3**: Create a `product-images` bucket
 - **Kafka**: Create a `stock-updates` topic
 
 Changes can be:
@@ -141,25 +160,6 @@ public class _002_CreateS3Bucket {
 For more details, see [Core concepts](core-concepts.md).
 
 
-## 3. Create target systems
-
-Target systems represent the external systems Flamingock will apply your changes to.
-They are configured in the builder and shared across Changes.
-
-For our example:
-- A MySQL database (`mysql-inventory`)
-- An S3 bucket service (`aws-s3`)  
-- A Kafka cluster (`kafka`)
-
-```java
-SqlTargetSystem sql = new SqlTargetSystem("mysql-inventory").withDatasource(ds);
-DefaultTargetSystem s3 = new DefaultTargetSystem("aws-s3");
-DefaultTargetSystem kafka = new DefaultTargetSystem("kafka");
-```
-
-See [Target systems](../target-systems/introduction.md) for more details.
-
-
 ## 4. Configure stages
 
 Flamingock organizes your changes in stages.  

docs/target-systems/couchbase-target-system.md

@@ -1,6 +1,6 @@
 ---
 title: Couchbase
-sidebar_position: 5
+sidebar_position: 6
 ---
 import Tabs from '@theme/Tabs';
 import TabItem from '@theme/TabItem';
@@ -43,11 +43,15 @@ implementation("com.couchbase.client:java-client:3.6.0")
 Configure the target system:
 
 ```java
-CouchbaseTargetSystem couchbaseTarget = new CouchbaseTargetSystem("user-database", cluster, bucket);
+CouchbaseTargetSystem couchbaseTarget = new CouchbaseTargetSystem("user-database-id", cluster, bucket);
 ```
 
 The constructor requires the target system name, Couchbase cluster, and bucket. Optional configurations can be added via `.withXXX()` methods.
 
+:::info Register Target System
+Once created, you need to register this target system with Flamingock. See [Registering target systems](introduction.md#registering-target-systems) for details.
+:::
+
 ## Target System Configuration
 
 The Couchbase target system uses Flamingock's [split dependency resolution architecture](introduction.md#dependency-injection) with separate flows for target system configuration and change execution dependencies.
@@ -61,11 +65,11 @@ These dependencies must be provided at target system creation time with **no glo
 | `Cluster` | `cluster` | Couchbase cluster connection - **required** for both target system configuration and change execution |
 | `Bucket` | `bucket` | Target bucket instance - **required** for both target system configuration and change execution |
 
-### Dependencies Available to Changes
+## Dependencies Available to Changes
 
 Changes can access dependencies through [dependency injection with fallback](../changes/anatomy-and-structure.md#method-parameters-and-dependency-injection):
 
-1. **Target system context** (highest priority) - `Cluster`, `Bucket`, `AttemptContext`, plus any added via `.addDependency()`
+1. **Target system context** (highest priority) - `Cluster`, `Bucket`, `TransactionAttemptContext`, plus any added via `.addDependency()`
 2. **Target system additional dependencies** - added via `.addDependency()` or `.setProperty()`
 3. **Global context** (fallback) - shared dependencies available to all target systems
 
@@ -93,7 +97,7 @@ Flamingock.builder()
 **Change dependency resolution for Changes in "user-database":**
 - **Cluster**: From target system context (`productionCluster`)
 - **Bucket**: From target system context (`userBucket`)
-- **AttemptContext**: From target system context (created by Flamingock)
+- **TransactionAttemptContext**: From target system context (created by Flamingock)
 - **AuditService**: From target system additional dependencies
 - **EmailService**: From global context (fallback)
 - **LogService**: From global context (fallback)
@@ -102,18 +106,18 @@ This architecture ensures explicit target system configuration while providing f
 
 ## Transactional support
 
-For a Change to leverage Couchbase's transactional capabilities, it must use the `AttemptContext` parameter. Flamingock uses the injected `Cluster` and `Bucket` dependencies to create and manage this context's lifecycle - creating the transaction context before execution, committing on success, and rolling back on failure.
+For a Change to leverage Couchbase's transactional capabilities, it must use the `TransactionAttemptContext` parameter. Flamingock uses the injected `Cluster` and `Bucket` dependencies to create and manage this context's lifecycle - creating the transaction context before execution, committing on success, and rolling back on failure.
 
 > For detailed information on transaction handling, see [Transactions](../changes/transactions.md).
 
 ```java
-@TargetSystem("user-database")
+@TargetSystem("user-database-id")
 @Change(id = "create-users", order = "001")
 public class CreateUsers {
 
     @Apply
-    public void apply(Cluster cluster, Bucket bucket, AttemptContext txContext) {
-        // AttemptContext is required for transactional execution
+    public void apply(Cluster cluster, Bucket bucket, TransactionAttemptContext txContext) {
+        // TransactionAttemptContext is required for transactional execution
         // Flamingock uses the target system's Cluster and Bucket to handle transaction operations
         // and manages transaction start, commit, and rollback automatically
         Collection collection = bucket.defaultCollection();
@@ -130,13 +134,13 @@ public class CreateUsers {
 You can also work with the Cluster and Bucket directly without transactions:
 
 ```java
-@TargetSystem("user-database")
+@TargetSystem("user-database-id")
 @Change(id = "update-configs", order = "002")
 public class UpdateConfigs {
 
     @Apply
     public void apply(Cluster cluster, Bucket bucket) {
-        // Operations without AttemptContext won't participate in transactions
+        // Operations without TransactionAttemptContext won't participate in transactions
         Collection collection = bucket.defaultCollection();
 
         JsonObject config = JsonObject.create()
@@ -149,15 +153,15 @@ public class UpdateConfigs {
 ```
 
 **How transactions work:**
-1. **Context creation**: Flamingock uses the target system's `Cluster` to create an `AttemptContext` for transaction management
+1. **Context creation**: Flamingock uses the target system's `Cluster` to create an `TransactionAttemptContext` for transaction management
 2. **Transaction management**: The same `Cluster` and `Bucket` handle transaction operations and coordinate with the context
 3. **Lifecycle**: Flamingock automatically creates the transaction context, commits on success, or rolls back on failure
 
-Without the `AttemptContext` parameter, operations will execute but won't participate in transactions.
+Without the `TransactionAttemptContext` parameter, operations will execute but won't participate in transactions.
 
 ## Available dependencies in Changes
 
-Your Changes can inject Couchbase-specific dependencies like `Cluster`, `Bucket`, and `AttemptContext` (for transactions), but are not limited to these. The target system provides these dependencies through its context, and you can add additional dependencies via `.addDependency()` that take precedence over global dependencies.
+Your Changes can inject Couchbase-specific dependencies like `Cluster`, `Bucket`, and `TransactionAttemptContext` (for transactions), but are not limited to these. The target system provides these dependencies through its context, and you can add additional dependencies via `.addDependency()` that take precedence over global dependencies.
 
 For comprehensive details on change dependency resolution, see [Change Anatomy & Structure](../changes/anatomy-and-structure.md).
 

docs/target-systems/dynamodb-target-system.md

@@ -1,6 +1,6 @@
 ---
 title: DynamoDB
-sidebar_position: 4
+sidebar_position: 5
 ---
 import Tabs from '@theme/Tabs';
 import TabItem from '@theme/TabItem';
@@ -43,11 +43,15 @@ implementation("software.amazon.awssdk:dynamodb-enhanced:2.12.0")
 Configure the target system:
 
 ```java
-DynamoDBTargetSystem dynamoTarget = new DynamoDBTargetSystem("inventory-database", dynamoDbClient);
+DynamoDBTargetSystem dynamoTarget = new DynamoDBTargetSystem("inventory-database-id", dynamoDbClient);
 ```
 
 The constructor requires the target system name and DynamoDB client. Optional configurations can be added via `.withXXX()` methods.
 
+:::info Register Target System
+Once created, you need to register this target system with Flamingock. See [Registering target systems](introduction.md#registering-target-systems) for details.
+:::
+
 ## Target System Configuration
 
 The DynamoDB target system uses Flamingock's [split dependency resolution architecture](introduction.md#dependency-injection) with separate flows for target system configuration and change execution dependencies.
@@ -60,7 +64,7 @@ These dependencies must be provided at target system creation time with **no glo
 |------------|----------------------|-------------|
 | `DynamoDbClient` | `dynamoDbClient` | AWS DynamoDB client - **required** for both target system configuration and change execution |
 
-### Dependencies Available to Changes
+## Dependencies Available to Changes
 
 Changes can access dependencies through [dependency injection with fallback](../changes/anatomy-and-structure.md#method-parameters-and-dependency-injection):
 
@@ -104,7 +108,7 @@ For a Change to leverage DynamoDB's transactional capabilities, it must use the
 > For detailed information on transaction handling, see [Transactions](../changes/transactions.md).
 
 ```java
-@TargetSystem("inventory-database")
+@TargetSystem("inventory-database-id")
 @Change(id = "update-inventory", order = "001")
 public class UpdateInventory {
 

docs/target-systems/introduction.md

@@ -3,6 +3,9 @@ title: Introduction
 sidebar_position: 0
 ---
 
+import Tabs from '@theme/Tabs';
+import TabItem from '@theme/TabItem';
+
 # Target systems
 
 Target systems are the real-world systems where your business changes are applied.
@@ -64,82 +67,69 @@ mongoTarget.withWriteConcern(WriteConcern.MAJORITY)
 **No global context fallback** - target system configuration must be explicit and complete.
 
 
-## Dependency injection
-
-Dependency injection is the mechanism used for **change execution**, providing the dependencies that Changes need to perform their operations. Each target system exposes specific dependencies required by its Changes:
-
-- A MongoDB target system provides a `MongoDatabase`, `ClientSession`
-- A Kafka target system provides a `KafkaTemplate`
-- A SQL target system provides a `Connection` or `DataSource`
-
-Flamingock uses a **flexible, multi-source approach** with fallback hierarchy for change execution:
-
-1. **Target system context** (highest priority) - includes configuration parameters from constructor + `.withXXX()` methods
-2. **Target system additional dependencies** - added via `.addDependency()` or `.setProperty()`
-3. **Global context** (fallback) - shared dependencies available to all target systems
-
-:::info 
-Target system configuration parameters (from **constructor** and `.withXXX()` methods) are automatically available as change dependencies with highest priority.
-:::
-
-For comprehensive details on change dependency resolution, see [Change Anatomy & Structure](../changes/anatomy-and-structure.md).
+## Registering target systems
 
+Target systems are registered at runtime. You can define and register as many as you need:
 
-## Registering target systems
+<Tabs groupId="registration">
+  <TabItem value="builder" label="Flamingock Builder" default>
 
-Target systems are registered at runtime with the Flamingock builder. You can define and register as many as you need:
+Use the Flamingock builder for standalone applications:
 
 ```java
+SqlTargetSystem mysql = new SqlTargetSystem("mysql-inventory-id", dataSource);
 
-SqlTargetSystem mysql = new SqlTargetSystem("mysql-inventory", dataSource);
-
-DefaultTargetSystem s3 = new DefaultTargetSystem("aws-s3");
+NonTransactionalTargetSystem s3 = new NonTransactionalTargetSystem("aws-s3-id");
 
-DefaultTargetSystem kafka = new DefaultTargetSystem("kafka-stock");
+NonTransactionalTargetSystem kafka = new NonTransactionalTargetSystem("kafka-stock-id");
 
 Flamingock.builder()
     .setAuditStore(new MongoSyncAuditStore(mongoClient, mongoDatabase))
     .addTargetSystems(mysql, s3, kafka)
     .build()
     .run();
-
 ```
 
 At startup, Flamingock automatically injects the right dependencies from the corresponding target system into each Change.
 
-### Spring Boot Integration
-For Spring Boot applications, target systems are configured as beans:
+  </TabItem>
+  <TabItem value="springboot" label="Spring Boot">
+
+For Spring Boot applications, register target systems as beans:
 
 ```java
 @Bean
 public SqlTargetSystem sqlTargetSystem(DataSource dataSource) {
-    return new SqlTargetSystem("mysql-inventory", dataSource);
+    return new SqlTargetSystem("mysql-inventory-id", dataSource);
 }
 
 @Bean
 public MongoSyncTargetSystem mongoTargetSystem(MongoClient mongoClient) {
-    return new MongoSyncTargetSystem("user-database", mongoClient, "userDb")
+    return new MongoSyncTargetSystem("user-database-id", mongoClient, "userDb")
         .withWriteConcern(WriteConcern.MAJORITY);
 }
 
 @Bean
-public DefaultTargetSystem kafkaTargetSystem() {
-    return new DefaultTargetSystem("kafka-stock");
+public NonTransactionalTargetSystem kafkaTargetSystem() {
+    return new NonTransactionalTargetSystem("kafka-stock-id");
 }
 ```
 
 Spring Boot's auto-configuration will automatically register these target systems with Flamingock.
 
 For more details, see [Spring Boot Integration](../frameworks/springboot-integration/introduction.md).
 
+  </TabItem>
+</Tabs>
+
 
 
 ## Linking Changes to target systems
 
 When defining Changes, you specify which target system they belong to using the `@TargetSystem` annotation:
 
 ```java
-@TargetSystem("mysql-inventory")
+@TargetSystem("mysql-inventory-id")
 @Change(id = "add-category", order = "001", author = "team")
 public class _001_AddCategory {
     //...
@@ -148,6 +138,27 @@ public class _001_AddCategory {
 
 
 
+## Dependency injection
+
+Dependency injection is the mechanism used for **change execution**, providing the dependencies that Changes need to perform their operations. Each target system exposes specific dependencies required by its Changes:
+
+- A MongoDB target system provides a `MongoDatabase`, `ClientSession`
+- A Kafka target system provides a `KafkaTemplate`
+- A SQL target system provides a `Connection` or `DataSource`
+
+Flamingock uses a **flexible, multi-source approach** with fallback hierarchy for change execution:
+
+1. **Target system context** (highest priority) - includes configuration parameters from constructor + `.withXXX()` methods
+2. **Target system additional dependencies** - added via `.addDependency()` or `.setProperty()`
+3. **Global context** (fallback) - shared dependencies available to all target systems
+
+:::info 
+Target system configuration parameters (from **constructor** and `.withXXX()` methods) are automatically available as change dependencies with highest priority.
+:::
+
+For comprehensive details on change dependency resolution, see [Change Anatomy & Structure](../changes/anatomy-and-structure.md).
+
+
 ## Cloud Edition visibility
 
 In the Cloud Edition, target systems become a first-class part of the dashboard:
@@ -184,7 +195,7 @@ These target systems provide optimized handling for specific technologies:
 ### Universal fallback
 For any system that doesn't require specialized handling:
 
-- [Default target system](../target-systems/default-target-system.md) - The fallback choice for any system without a dedicated implementation (Kafka Schema Registry, S3, REST APIs, file systems, etc.)
+- [Non-transactional target system](../target-systems/non-transactional-target-system.md) - The fallback choice for any system without a dedicated implementation (Kafka Schema Registry, S3, REST APIs, file systems, etc.)
 
 **Future extensibility**: The Flamingock ecosystem may expand with more specialized target systems as specific needs are identified. These can be implemented by the Flamingock team, community contributions, or custom implementations by users.