org.springframework.transaction.reactive.TransactionalOperator

@Test
void auditingOfModificationShouldWork(@Autowired ImmutableEnreplacedyTestRepository repository) {
    Mono<ImmutableAuditableThing> findAndUpdateAThing = repository.findById(idOfExistingThing).flatMap(thing -> repository.save(thing.withName("A new name")));
    TransactionalOperator transactionalOperator = TransactionalOperator.create(transactionManager);
    transactionalOperator.execute(t -> findAndUpdateAThing).as(StepVerifier::create).consumeNextWith(savedThing -> {
        replacedertThat(savedThing.getCreatedAt()).isEqualTo(EXISTING_THING_CREATED_AT);
        replacedertThat(savedThing.getCreatedBy()).isEqualTo(EXISTING_THING_CREATED_BY);
        replacedertThat(savedThing.getModifiedAt()).isEqualTo(DEFAULT_CREATION_AND_MODIFICATION_DATE);
        replacedertThat(savedThing.getModifiedBy()).isEqualTo("A user");
        replacedertThat(savedThing.getName()).isEqualTo("A new name");
    }).verifyComplete();
    // Need to happen outside the reactive flow, as we use the blocking session to verify the database
    verifyDatabase(idOfExistingThing, new ImmutableAuditableThing(null, EXISTING_THING_CREATED_AT, EXISTING_THING_CREATED_BY, DEFAULT_CREATION_AND_MODIFICATION_DATE, "A user", "A new name"));
}

@Test
void auditingOfEnreplacedyWithGeneratedIdModificationShouldWork(@Autowired ImmutableEnreplacedyWithGeneratedIdTestRepository repository) {
    Mono<ImmutableAuditableThingWithGeneratedId> findAndUpdateAThing = repository.findById(idOfExistingThingWithGeneratedId).flatMap(thing -> repository.save(thing.withName("A new name")));
    TransactionalOperator transactionalOperator = TransactionalOperator.create(transactionManager);
    transactionalOperator.execute(t -> findAndUpdateAThing).as(StepVerifier::create).consumeNextWith(savedThing -> {
        replacedertThat(savedThing.getCreatedAt()).isEqualTo(EXISTING_THING_CREATED_AT);
        replacedertThat(savedThing.getCreatedBy()).isEqualTo(EXISTING_THING_CREATED_BY);
        replacedertThat(savedThing.getModifiedAt()).isEqualTo(DEFAULT_CREATION_AND_MODIFICATION_DATE);
        replacedertThat(savedThing.getModifiedBy()).isEqualTo("A user");
        replacedertThat(savedThing.getName()).isEqualTo("A new name");
    }).verifyComplete();
    // Need to happen outside the reactive flow, as we use the blocking session to verify the database
    verifyDatabase(idOfExistingThingWithGeneratedId, new ImmutableAuditableThingWithGeneratedId(null, EXISTING_THING_CREATED_AT, EXISTING_THING_CREATED_BY, DEFAULT_CREATION_AND_MODIFICATION_DATE, "A user", "A new name"));
}

clreplaced TransactionalRowsFetchSpec<T> implements RowsFetchSpec<T> {

    private final RowsFetchSpec<T> rowsFetchSpec;

    private final TransactionalOperator transactionalOperator;

    TransactionalRowsFetchSpec(RowsFetchSpec<T> rowsFetchSpec, TransactionalOperator transactionalOperator) {
        this.rowsFetchSpec = rowsFetchSpec;
        this.transactionalOperator = transactionalOperator;
    }

    @Override
    public Mono<T> one() {
        return rowsFetchSpec.one().as(transactionalOperator::transactional);
    }

    @Override
    public Mono<T> first() {
        return rowsFetchSpec.first().as(transactionalOperator::transactional);
    }

    @Override
    public Flux<T> all() {
        return rowsFetchSpec.all().as(transactionalOperator::transactional);
    }
}

@Override
public Single<Scope> update(Scope item) {
    LOGGER.debug("Update Scope with id {}", item.getId());
    TransactionalOperator trx = TransactionalOperator.create(tm);
    Mono<Integer> deleteClaims = dbClient.delete().from(JdbcScope.Claims.clreplaced).matching(from(where("scope_id").is(item.getId()))).fetch().rowsUpdated();
    final DatabaseClient.GenericUpdateSpec updateSpec = dbClient.update().table("scopes");
    // doesn't use the clreplaced introspection to detect the fields due to keyword column name
    Map<SqlIdentifier, Object> updateFields = new HashMap<>();
    updateFields = addQuotedField(updateFields, "id", item.getId(), String.clreplaced);
    updateFields = addQuotedField(updateFields, "name", item.getName(), String.clreplaced);
    updateFields = addQuotedField(updateFields, "domain", item.getDomain(), String.clreplaced);
    updateFields = addQuotedField(updateFields, "description", item.getDescription(), String.clreplaced);
    updateFields = addQuotedField(updateFields, "expires_in", item.getExpiresIn(), Integer.clreplaced);
    updateFields = addQuotedField(updateFields, "icon_uri", item.getIconUri(), String.clreplaced);
    // mssql keyword
    updateFields = addQuotedField(updateFields, "key", item.getKey(), String.clreplaced);
    updateFields = addQuotedField(updateFields, "discovery", item.isDiscovery(), Boolean.clreplaced);
    updateFields = addQuotedField(updateFields, "system", item.isSystem(), Boolean.clreplaced);
    updateFields = addQuotedField(updateFields, "created_at", dateConverter.convertTo(item.getCreatedAt(), null), LocalDateTime.clreplaced);
    updateFields = addQuotedField(updateFields, "updated_at", dateConverter.convertTo(item.getUpdatedAt(), null), LocalDateTime.clreplaced);
    Mono<Integer> action = updateSpec.using(Update.from(updateFields)).matching(from(where("id").is(item.getId()))).fetch().rowsUpdated();
    final List<String> scopeClaims = item.getClaims();
    if (scopeClaims != null && !scopeClaims.isEmpty()) {
        action = action.then(Flux.fromIterable(scopeClaims).concatMap(claim -> {
            JdbcScope.Claims sClaim = new JdbcScope.Claims();
            sClaim.setClaim(claim);
            sClaim.setScopeId(item.getId());
            return dbClient.insert().into(JdbcScope.Claims.clreplaced).using(sClaim).fetch().rowsUpdated();
        }).reduce(Integer::sum));
    }
    return monoToSingle(deleteClaims.then(action).as(trx::transactional)).flatMap((i) -> this.findById(item.getId()).toSingle()).doOnError((error) -> LOGGER.error("Unable to update Resource with id {}", item.getId(), error));
}

@Override
public Completable delete(String id) {
    LOGGER.debug("delete({})", id);
    TransactionalOperator trx = TransactionalOperator.create(tm);
    Mono<Integer> deleteClaim = dbClient.delete().from(JdbcScope.Claims.clreplaced).matching(from(where("scope_id").is(id))).fetch().rowsUpdated();
    Mono<Integer> delete = dbClient.delete().from(JdbcScope.clreplaced).matching(from(where("id").is(id))).fetch().rowsUpdated();
    return monoToCompletable(deleteClaim.then(delete).as(trx::transactional)).doOnError(error -> LOGGER.error("Unable to delete scope with id {}", id, error));
}

@Override
public Completable delete(String id) {
    LOGGER.debug("Delete Role with id {}", id);
    TransactionalOperator trx = TransactionalOperator.create(tm);
    Mono<Integer> deleteScopes = dbClient.delete().from(JdbcRole.OAuthScope.clreplaced).matching(from(where("role_id").is(id))).fetch().rowsUpdated();
    Mono<Integer> delete = dbClient.delete().from(JdbcRole.clreplaced).matching(from(where("id").is(id))).fetch().rowsUpdated();
    return monoToCompletable(delete.then(deleteScopes.as(trx::transactional))).doOnError(error -> LOGGER.error("Unable to delete Role with id {}", id, error));
}

@Override
public Completable delete(String id) {
    LOGGER.debug("delete({})", id);
    TransactionalOperator trx = TransactionalOperator.create(tm);
    Mono<Integer> delete = dbClient.delete().from(JdbcEntrypoint.clreplaced).matching(from(where("id").is(id))).fetch().rowsUpdated();
    return monoToCompletable(deleteTags(id).then(delete).as(trx::transactional)).doOnError(error -> LOGGER.error("Unable to delete entrypoint with id {}", id, error));
}

@Test
void onBeforeBindShouldBeCalledForSingleEnreplacedy(@Autowired ReactiveThingRepository repository) {
    ThingWithreplacedignedId thing = new ThingWithreplacedignedId("aaBB");
    thing.setName("A name");
    Mono<ThingWithreplacedignedId> operationUnderTest = Mono.just(thing).flatMap(repository::save);
    List<ThingWithreplacedignedId> savedThings = new ArrayList<>();
    TransactionalOperator transactionalOperator = TransactionalOperator.create(transactionManager);
    transactionalOperator.execute(t -> operationUnderTest).as(StepVerifier::create).recordWith(() -> savedThings).expectNextMatches(t -> t.getName().equals("A name (Edited)")).verifyComplete();
    verifyDatabase(savedThings);
}

@Service
@RequiredArgsConstructor
clreplaced ReservationService {

    private final ReservationRepository reservationRepository;

    private final TransactionalOperator transactionalOperator;

    // @Transactional
    public Flux<Reservation> save(String... names) {
        Flux<Reservation> reservations = Flux.just(names).map(name -> new Reservation(null, name)).flatMap(this.reservationRepository::save).doOnNext(r -> validateName(r.getName()));
        return transactionalOperator.transactional(reservations);
    }

    private static void validateEmail(String email) {
        replacedert.isTrue(email != null && email.length() > 0 && email.contains("@"), "the email is invalid!");
    }

    private static void validateName(String name) {
        replacedert.isTrue(name != null, "the name can't be null");
        replacedert.isTrue(name.length() > 0, "the name can't be null");
        var firstChar = name.charAt(0);
        replacedert.isTrue(Character.isUpperCase(firstChar), "the first char must be uppercase!");
    }
}

@Bean
ApplicationRunner initialize(DatabaseClient databaseClient, PostRepository posts, CommentRepository comments, TransactionalOperator operator) {
    log.info("start data initialization...");
    return args -> {
        databaseClient.sql("INSERT INTO  posts (replacedle, content, metadata) VALUES (:replacedle, :content, :metadata)").filter((statement, executeFunction) -> statement.returnGeneratedValues("id").execute()).bind("replacedle", "my first post").bind("content", "content of my first post").bind("metadata", Json.of("{\"tags\":[\"spring\", \"r2dbc\"]}")).fetch().first().subscribe(data -> log.info("inserted data : {}", data), error -> log.error("error: {}", error));
        posts.save(Post.builder().replacedle("another post").content("content of another post").build()).map(p -> {
            p.setreplacedle("new replacedle");
            return p;
        }).flatMap(posts::save).flatMap(saved -> comments.save(Comment.builder().content("dummy comments").postId(saved.getId()).build())).log().then().thenMany(posts.findAll()).as(operator::transactional).subscribe(data -> log.info("saved data: {}", data), err -> log.error("err: {}", err));
    };
}

@Override
public Completable delete(String id) {
    LOGGER.debug("delete({})", id);
    TransactionalOperator trx = TransactionalOperator.create(tm);
    Mono<Integer> delete = dbClient.delete().from(JdbcUser.clreplaced).matching(from(where("id").is(id))).fetch().rowsUpdated();
    return monoToCompletable(delete.then(deleteChildEnreplacedies(id)).as(trx::transactional)).doOnError(error -> LOGGER.error("Unable to delete user with id {}", id));
}

@Override
public Single<Scope> create(Scope item) {
    item.setId(item.getId() == null ? RandomString.generate() : item.getId());
    LOGGER.debug("Create Scope with id {}", item.getId());
    TransactionalOperator trx = TransactionalOperator.create(tm);
    DatabaseClient.GenericInsertSpec<Map<String, Object>> insertSpec = dbClient.insert().into("scopes");
    // doesn't use the clreplaced introspection to detect the fields due to keyword column name
    insertSpec = addQuotedField(insertSpec, "id", item.getId(), String.clreplaced);
    insertSpec = addQuotedField(insertSpec, "name", item.getName(), String.clreplaced);
    insertSpec = addQuotedField(insertSpec, "domain", item.getDomain(), String.clreplaced);
    insertSpec = addQuotedField(insertSpec, "description", item.getDescription(), String.clreplaced);
    insertSpec = addQuotedField(insertSpec, "expires_in", item.getExpiresIn(), Integer.clreplaced);
    insertSpec = addQuotedField(insertSpec, "icon_uri", item.getIconUri(), String.clreplaced);
    // mssql keyword
    insertSpec = addQuotedField(insertSpec, "key", item.getKey(), String.clreplaced);
    insertSpec = addQuotedField(insertSpec, "discovery", item.isDiscovery(), Boolean.clreplaced);
    insertSpec = addQuotedField(insertSpec, "system", item.isSystem(), Boolean.clreplaced);
    insertSpec = addQuotedField(insertSpec, "created_at", dateConverter.convertTo(item.getCreatedAt(), null), LocalDateTime.clreplaced);
    insertSpec = addQuotedField(insertSpec, "updated_at", dateConverter.convertTo(item.getUpdatedAt(), null), LocalDateTime.clreplaced);
    Mono<Integer> action = insertSpec.fetch().rowsUpdated();
    final List<String> scopeClaims = item.getClaims();
    if (scopeClaims != null && !scopeClaims.isEmpty()) {
        action = action.then(Flux.fromIterable(scopeClaims).concatMap(claim -> {
            JdbcScope.Claims sClaim = new JdbcScope.Claims();
            sClaim.setClaim(claim);
            sClaim.setScopeId(item.getId());
            return dbClient.insert().into(JdbcScope.Claims.clreplaced).using(sClaim).fetch().rowsUpdated();
        }).reduce(Integer::sum));
    }
    return monoToSingle(action.as(trx::transactional)).flatMap((i) -> this.findById(item.getId()).toSingle()).doOnError((error) -> LOGGER.error("Unable to create Resource with id {}", item.getId(), error));
}

@Override
public Completable delete(String id) {
    LOGGER.debug("Delete Resource with id {}", id);
    TransactionalOperator trx = TransactionalOperator.create(tm);
    Mono<Integer> deleteScopes = dbClient.delete().from(JdbcResource.Scope.clreplaced).matching(from(where("resource_id").is(id))).fetch().rowsUpdated();
    Mono<Integer> delete = dbClient.delete().from(JdbcResource.clreplaced).matching(from(where("id").is(id))).fetch().rowsUpdated();
    return monoToCompletable(delete.then(deleteScopes).as(trx::transactional)).doOnError(error -> LOGGER.error("Unable to delete Resource with {}", id, error));
}

@Override
public Completable delete(String organizationId) {
    LOGGER.debug("delete organization with id {}", organizationId);
    TransactionalOperator trx = TransactionalOperator.create(tm);
    Mono<Void> deleteIdenreplacedies = deleteIdenreplacedies(organizationId);
    Mono<Void> deleteDomainRestrictions = deleteDomainRestrictions(organizationId);
    Mono<Void> deleteHrids = deleteHrids(organizationId);
    Mono<Void> delete = dbClient.delete().from(JdbcOrganization.clreplaced).matching(from(where("id").is(organizationId))).then();
    return monoToCompletable(delete.then(deleteDomainRestrictions).then(deleteIdenreplacedies).then(deleteHrids).as(trx::transactional));
}

@Override
public Completable delete(String id) {
    LOGGER.debug("delete Group with id {}", id);
    TransactionalOperator trx = TransactionalOperator.create(tm);
    Mono<Integer> delete = dbClient.delete().from(databaseDialectHelper.toSql(quoted("groups"))).matching(from(where("id").is(id))).fetch().rowsUpdated();
    return monoToCompletable(delete.then(deleteChildEnreplacedies(id)).as(trx::transactional)).doOnError((error) -> LOGGER.error("unable to delete Group with id {}", id, error));
}

@Override
public Completable delete(String id) {
    LOGGER.debug("delete Flow with id {}", id);
    TransactionalOperator trx = TransactionalOperator.create(tm);
    return monoToCompletable(dbClient.delete().from(JdbcFlow.clreplaced).matching(from(where("id").is(id))).fetch().rowsUpdated().then(deleteChildEnreplacedies(id)).as(trx::transactional)).doOnError((error) -> LOGGER.error("Unable to delete Flow with id {}", id, error));
}

@Override
public Completable delete(String environmentId) {
    LOGGER.debug("delete environment with id {}", environmentId);
    TransactionalOperator trx = TransactionalOperator.create(tm);
    Mono<Void> deleteDomainRestrictions = deleteDomainRestrictions(environmentId);
    Mono<Void> deleteHrids = deleteHrids(environmentId);
    Mono<Void> delete = dbClient.delete().from(JdbcEnvironment.clreplaced).matching(from(where("id").is(environmentId))).then();
    return monoToCompletable(delete.then(deleteDomainRestrictions).then(deleteHrids).as(trx::transactional));
}

@Override
public Single<Entrypoint> create(Entrypoint item) {
    item.setId(item.getId() == null ? RandomString.generate() : item.getId());
    LOGGER.debug("create Entrypoint with id {}", item.getId());
    TransactionalOperator trx = TransactionalOperator.create(tm);
    Mono<Integer> action = dbClient.insert().into(JdbcEntrypoint.clreplaced).using(toJdbcEnreplacedy(item)).fetch().rowsUpdated();
    final List<String> tags = item.getTags();
    if (tags != null && !tags.isEmpty()) {
        action = action.then(Flux.fromIterable(tags).concatMap(tagValue -> {
            JdbcEntrypoint.Tag tag = new JdbcEntrypoint.Tag();
            tag.setTag(tagValue);
            tag.setEntrypointId(item.getId());
            return dbClient.insert().into(JdbcEntrypoint.Tag.clreplaced).using(tag).fetch().rowsUpdated();
        }).reduce(Integer::sum));
    }
    return monoToSingle(action.as(trx::transactional)).flatMap((i) -> this.findById(item.getId()).toSingle()).doOnError((error) -> LOGGER.error("unable to create entrypoint with id {}", item.getId(), error));
}

@Override
public Single<Entrypoint> update(Entrypoint item) {
    LOGGER.debug("update Entrypoint with id {}", item.getId());
    TransactionalOperator trx = TransactionalOperator.create(tm);
    Mono<Integer> action = dbClient.update().table(JdbcEntrypoint.clreplaced).using(toJdbcEnreplacedy(item)).fetch().rowsUpdated();
    final List<String> tags = item.getTags();
    if (tags != null & !tags.isEmpty()) {
        action = action.then(Flux.fromIterable(tags).concatMap(tagValue -> {
            JdbcEntrypoint.Tag tag = new JdbcEntrypoint.Tag();
            tag.setTag(tagValue);
            tag.setEntrypointId(item.getId());
            return dbClient.insert().into(JdbcEntrypoint.Tag.clreplaced).using(tag).fetch().rowsUpdated();
        }).reduce(Integer::sum));
    }
    return monoToSingle(deleteTags(item.getId()).then(action).as(trx::transactional)).flatMap((i) -> this.findById(item.getId()).toSingle()).doOnError((error) -> LOGGER.error("unable to create entrypoint with id {}", item.getId(), error));
}

@Override
public Completable delete(String domainId) {
    LOGGER.debug("delete Domain with id {}", domainId);
    TransactionalOperator trx = TransactionalOperator.create(tm);
    return monoToCompletable(dbClient.delete().from(JdbcDomain.clreplaced).matching(from(where("id").is(domainId))).fetch().rowsUpdated().then(deleteChildEnreplacedies(domainId)).as(trx::transactional)).doOnError((error) -> LOGGER.error("unable to delete Domain with id {}", domainId, error));
}

@Test
void onBeforeBindShouldBeCalledForAllEnreplacediesUsingIterable(@Autowired ReactiveThingRepository repository) {
    ThingWithreplacedignedId thing1 = new ThingWithreplacedignedId("id1");
    thing1.setName("A name");
    ThingWithreplacedignedId thing2 = new ThingWithreplacedignedId("id2");
    thing2.setName("Another name");
    repository.saveAll(Arrays.asList(thing1, thing2));
    Flux<ThingWithreplacedignedId> operationUnderTest = repository.saveAll(Arrays.asList(thing1, thing2));
    List<ThingWithreplacedignedId> savedThings = new ArrayList<>();
    TransactionalOperator transactionalOperator = TransactionalOperator.create(transactionManager);
    transactionalOperator.execute(t -> operationUnderTest).as(StepVerifier::create).recordWith(() -> savedThings).expectNextMatches(t -> t.getName().equals("A name (Edited)")).expectNextMatches(t -> t.getName().equals("Another name (Edited)")).verifyComplete();
    verifyDatabase(savedThings);
}

@Test
void onBeforeBindShouldBeCalledForAllEnreplacediesUsingPublisher(@Autowired ReactiveThingRepository repository) {
    ThingWithreplacedignedId thing1 = new ThingWithreplacedignedId("id1");
    thing1.setName("A name");
    ThingWithreplacedignedId thing2 = new ThingWithreplacedignedId("id2");
    thing2.setName("Another name");
    repository.saveAll(Arrays.asList(thing1, thing2));
    Flux<ThingWithreplacedignedId> operationUnderTest = repository.saveAll(Flux.just(thing1, thing2));
    List<ThingWithreplacedignedId> savedThings = new ArrayList<>();
    TransactionalOperator transactionalOperator = TransactionalOperator.create(transactionManager);
    transactionalOperator.execute(t -> operationUnderTest).as(StepVerifier::create).recordWith(() -> savedThings).expectNextMatches(t -> t.getName().equals("A name (Edited)")).expectNextMatches(t -> t.getName().equals("Another name (Edited)")).verifyComplete();
    verifyDatabase(savedThings);
}

@Test
void auditingOfEnreplacedyWithGeneratedIdCreationShouldWork(@Autowired ImmutableEnreplacedyWithGeneratedIdTestRepository repository) {
    List<ImmutableAuditableThingWithGeneratedId> newThings = new ArrayList<>();
    TransactionalOperator transactionalOperator = TransactionalOperator.create(transactionManager);
    transactionalOperator.execute(t -> repository.save(new ImmutableAuditableThingWithGeneratedId("A thing"))).as(StepVerifier::create).recordWith(() -> newThings).expectNextCount(1L).verifyComplete();
    ImmutableAuditableThingWithGeneratedId savedThing = newThings.get(0);
    replacedertThat(savedThing.getCreatedAt()).isEqualTo(DEFAULT_CREATION_AND_MODIFICATION_DATE);
    replacedertThat(savedThing.getCreatedBy()).isEqualTo("A user");
    replacedertThat(savedThing.getModifiedAt()).isNull();
    replacedertThat(savedThing.getModifiedBy()).isNull();
    verifyDatabase(savedThing.getId(), savedThing);
}

@Test
void auditingOfCreationShouldWork(@Autowired ImmutableEnreplacedyTestRepository repository) {
    List<ImmutableAuditableThing> newThings = new ArrayList<>();
    TransactionalOperator transactionalOperator = TransactionalOperator.create(transactionManager);
    transactionalOperator.execute(t -> repository.save(new ImmutableAuditableThing("A thing"))).as(StepVerifier::create).recordWith(() -> newThings).expectNextCount(1L).verifyComplete();
    ImmutableAuditableThing savedThing = newThings.get(0);
    replacedertThat(savedThing.getCreatedAt()).isEqualTo(DEFAULT_CREATION_AND_MODIFICATION_DATE);
    replacedertThat(savedThing.getCreatedBy()).isEqualTo("A user");
    replacedertThat(savedThing.getModifiedAt()).isNull();
    replacedertThat(savedThing.getModifiedBy()).isNull();
    verifyDatabase(savedThing.getId(), savedThing);
}

@Override
public Single<Role> update(Role item) {
    LOGGER.debug("Update Role with id {}", item.getId());
    TransactionalOperator trx = TransactionalOperator.create(tm);
    Mono<Integer> deleteScopes = dbClient.delete().from(JdbcRole.OAuthScope.clreplaced).matching(from(where("role_id").is(item.getId()))).fetch().rowsUpdated();
    final DatabaseClient.GenericUpdateSpec updateSpec = dbClient.update().table("roles");
    Map<SqlIdentifier, Object> updateFields = new HashMap<>();
    // doesn't use the clreplaced introspection to allow the usage of Json type in PostgreSQL
    updateFields = addQuotedField(updateFields, "id", item.getId(), String.clreplaced);
    updateFields = addQuotedField(updateFields, "name", item.getName(), String.clreplaced);
    updateFields = addQuotedField(updateFields, "system", item.isSystem(), String.clreplaced);
    updateFields = addQuotedField(updateFields, "default_role", item.isDefaultRole(), String.clreplaced);
    updateFields = addQuotedField(updateFields, "description", item.getDescription(), String.clreplaced);
    updateFields = addQuotedField(updateFields, "reference_id", item.getReferenceId(), String.clreplaced);
    updateFields = addQuotedField(updateFields, "reference_type", item.getReferenceType() == null ? null : item.getReferenceType().name(), String.clreplaced);
    updateFields = addQuotedField(updateFields, "replacedignable_type", item.getreplacedignableType() == null ? null : item.getreplacedignableType().name(), String.clreplaced);
    updateFields = addQuotedField(updateFields, "created_at", dateConverter.convertTo(item.getCreatedAt(), null), LocalDateTime.clreplaced);
    updateFields = addQuotedField(updateFields, "updated_at", dateConverter.convertTo(item.getUpdatedAt(), null), LocalDateTime.clreplaced);
    updateFields = databaseDialectHelper.addJsonField(updateFields, "permission_acls", item.getPermissionAcls());
    Mono<Integer> action = updateSpec.using(Update.from(updateFields)).matching(from(where("id").is(item.getId()))).fetch().rowsUpdated();
    final List<String> resourceScopes = item.getOauthScopes();
    if (resourceScopes != null && !resourceScopes.isEmpty()) {
        action = action.then(Flux.fromIterable(resourceScopes).concatMap(scope -> {
            JdbcRole.OAuthScope rScope = new JdbcRole.OAuthScope();
            rScope.setScope(scope);
            rScope.setRoleId(item.getId());
            return dbClient.insert().into(JdbcRole.OAuthScope.clreplaced).using(rScope).fetch().rowsUpdated();
        }).reduce(Integer::sum));
    }
    return monoToSingle(deleteScopes.then(action).as(trx::transactional)).flatMap((i) -> this.findById(item.getId()).toSingle()).doOnError((error) -> LOGGER.error("Unable to update Role with id {}", item.getId(), error));
}

@Override
public Single<Role> create(Role item) {
    item.setId(item.getId() == null ? RandomString.generate() : item.getId());
    LOGGER.debug("Create Role with id {}", item.getId());
    TransactionalOperator trx = TransactionalOperator.create(tm);
    DatabaseClient.GenericInsertSpec<Map<String, Object>> insertSpec = dbClient.insert().into("roles");
    // doesn't use the clreplaced introspection to allow the usage of Json type in PostgreSQL
    insertSpec = addQuotedField(insertSpec, "id", item.getId(), String.clreplaced);
    insertSpec = addQuotedField(insertSpec, "name", item.getName(), String.clreplaced);
    insertSpec = addQuotedField(insertSpec, "system", item.isSystem(), String.clreplaced);
    insertSpec = addQuotedField(insertSpec, "default_role", item.isDefaultRole(), String.clreplaced);
    insertSpec = addQuotedField(insertSpec, "description", item.getDescription(), String.clreplaced);
    insertSpec = addQuotedField(insertSpec, "reference_id", item.getReferenceId(), String.clreplaced);
    insertSpec = addQuotedField(insertSpec, "reference_type", item.getReferenceType() == null ? null : item.getReferenceType().name(), String.clreplaced);
    insertSpec = addQuotedField(insertSpec, "replacedignable_type", item.getreplacedignableType() == null ? null : item.getreplacedignableType().name(), String.clreplaced);
    insertSpec = addQuotedField(insertSpec, "created_at", dateConverter.convertTo(item.getCreatedAt(), null), LocalDateTime.clreplaced);
    insertSpec = addQuotedField(insertSpec, "updated_at", dateConverter.convertTo(item.getUpdatedAt(), null), LocalDateTime.clreplaced);
    insertSpec = databaseDialectHelper.addJsonField(insertSpec, "permission_acls", item.getPermissionAcls());
    Mono<Integer> action = insertSpec.fetch().rowsUpdated();
    final List<String> resourceScopes = item.getOauthScopes();
    if (resourceScopes != null && !resourceScopes.isEmpty()) {
        action = action.then(Flux.fromIterable(resourceScopes).concatMap(scope -> {
            JdbcRole.OAuthScope rScope = new JdbcRole.OAuthScope();
            rScope.setScope(scope);
            rScope.setRoleId(item.getId());
            return dbClient.insert().into(JdbcRole.OAuthScope.clreplaced).using(rScope).fetch().rowsUpdated();
        }).reduce(Integer::sum));
    }
    return monoToSingle(action.as(trx::transactional)).flatMap((i) -> this.findById(item.getId()).toSingle()).doOnError((error) -> LOGGER.error("Unable to create Role with id {}", item.getId(), error));
}

@Override
public Single<Resource> update(Resource item) {
    LOGGER.debug("update Resource with id {}", item.getId());
    TransactionalOperator trx = TransactionalOperator.create(tm);
    Mono<Integer> deleteScopes = dbClient.delete().from(JdbcResource.Scope.clreplaced).matching(from(where("resource_id").is(item.getId()))).fetch().rowsUpdated();
    Mono<Integer> updateResource = dbClient.update().table(JdbcResource.clreplaced).using(toJdbcEnreplacedy(item)).matching(from(where("id").is(item.getId()))).fetch().rowsUpdated();
    final List<String> resourceScopes = item.getResourceScopes();
    if (resourceScopes != null && !resourceScopes.isEmpty()) {
        updateResource = updateResource.then(Flux.fromIterable(resourceScopes).concatMap(scope -> {
            JdbcResource.Scope rScope = new JdbcResource.Scope();
            rScope.setScope(scope);
            rScope.setResourceId(item.getId());
            return dbClient.insert().into(JdbcResource.Scope.clreplaced).using(rScope).fetch().rowsUpdated();
        }).reduce(Integer::sum));
    }
    return monoToSingle(deleteScopes.then(updateResource).as(trx::transactional)).flatMap((i) -> this.findById(item.getId()).toSingle()).doOnError((error) -> LOGGER.error("unable to update Resource with id {}", item.getId(), error));
}

@Override
public Single<Organization> update(Organization organization) {
    LOGGER.debug("update organization with id {}", organization.getId());
    TransactionalOperator trx = TransactionalOperator.create(tm);
    // prepare the update for organization table
    Mono<Void> update = dbClient.update().table(JdbcOrganization.clreplaced).using(toJdbcOrganization(organization)).matching(from(where("id").is(organization.getId()))).then();
    final Mono<Void> storeIdenreplacedies = storeIdenreplacedies(organization, true);
    final Mono<Void> storeDomainRestrictions = storeDomainRestrictions(organization, true);
    final Mono<Void> storeHrids = storeHrids(organization, true);
    return monoToSingle(update.then(storeIdenreplacedies).then(storeDomainRestrictions).then(storeHrids).as(trx::transactional).then(maybeToMono(findById(organization.getId()))));
}

@Override
public Single<Domain> update(Domain item) {
    LOGGER.debug("update Domain with id {}", item.getId());
    TransactionalOperator trx = TransactionalOperator.create(tm);
    Mono<Integer> updateAction = dbClient.update().table(JdbcDomain.clreplaced).using(toJdbcDomain(item)).fetch().rowsUpdated();
    updateAction = updateAction.then(deleteChildEnreplacedies(item.getId()));
    updateAction = persistChildEnreplacedies(updateAction, item);
    return monoToSingle(updateAction.as(trx::transactional)).flatMap((i) -> this.findById(item.getId()).toSingle()).doOnError((error) -> LOGGER.error("unable to update domain with id {}", item.getId(), error));
}

@Override
public Completable delete(String id) {
    LOGGER.debug("delete({})", id);
    TransactionalOperator trx = TransactionalOperator.create(tm);
    Mono<Integer> delete = dbClient.delete().from(JdbcApplication.clreplaced).matching(from(where("id").is(id))).fetch().rowsUpdated();
    return monoToCompletable(delete.then(deleteChildEnreplacedies(id)).as(trx::transactional)).andThen(applicationRepository.deleteById(id)).doOnError(error -> LOGGER.error("Unable to delete Application with id {}", id, error));
}

@Test
public void triggerRollbackCorrectly() {
    FirestoreTemplate template = getFirestoreTemplate();
    ReactiveFirestoreTransactionManager txManager = new ReactiveFirestoreTransactionManager(this.firestoreStub, this.parent);
    TransactionalOperator operator = TransactionalOperator.create(txManager);
    template.findById(Mono.defer(() -> {
        throw new FirestoreDataException("BOOM!");
    }), FirestoreTemplateTests.TestEnreplacedy.clreplaced).as(operator::transactional).as(StepVerifier::create).expectError().verify();
    verify(this.firestoreStub, times(1)).beginTransaction(any(), any());
    verify(this.firestoreStub, times(0)).commit(any(), any());
    verify(this.firestoreStub, times(1)).rollback(any(), any());
}

// end::repository_built_in[]
@Test
public void transactionalOperatorTest() {
    // tag::repository_transactional_operator[]
    DefaultTransactionDefinition transactionDefinition = new DefaultTransactionDefinition();
    transactionDefinition.setReadOnly(false);
    TransactionalOperator operator = TransactionalOperator.create(this.txManager, transactionDefinition);
    // end::repository_transactional_operator[]
    // tag::repository_operations_in_a_transaction[]
    User alice = new User("Alice", 29);
    User bob = new User("Bob", 60);
    this.userRepository.save(alice).then(this.userRepository.save(bob)).as(operator::transactional).block();
    this.userRepository.findAll().flatMap(a -> {
        a.setAge(a.getAge() - 1);
        return this.userRepository.save(a);
    }).as(operator::transactional).collectList().block();
    replacedertThat(this.userRepository.findAll().map(User::getAge).collectList().block()).containsExactlyInAnyOrder(28, 59);
// end::repository_operations_in_a_transaction[]
}

@Test
public void transactionTest() {
    User alice = new User("Alice", 29);
    User bob = new User("Bob", 60);
    User user = new User(null, 40);
    DefaultTransactionDefinition transactionDefinition = new DefaultTransactionDefinition();
    transactionDefinition.setReadOnly(false);
    TransactionalOperator operator = TransactionalOperator.create(this.txManager, transactionDefinition);
    reset(this.txManager);
    this.firestoreTemplate.save(alice).then(this.firestoreTemplate.save(bob)).then(this.firestoreTemplate.save(user)).as(operator::transactional).block();
    replacedertThat(this.firestoreTemplate.findAll(User.clreplaced).collectList().block()).containsExactlyInAnyOrder(bob, alice, user);
    verify(this.txManager, times(1)).commit(any());
    verify(this.txManager, times(0)).rollback(any());
    verify(this.txManager, times(1)).getReactiveTransaction(any());
    reset(this.txManager);
    // test rollback
    this.firestoreTemplate.saveAll(Mono.defer(() -> {
        throw new FirestoreDataException("BOOM!");
    })).then(this.firestoreTemplate.deleteAll(User.clreplaced)).as(operator::transactional).onErrorResume(throwable -> Mono.empty()).block();
    verify(this.txManager, times(0)).commit(any());
    verify(this.txManager, times(1)).rollback(any());
    verify(this.txManager, times(1)).getReactiveTransaction(any());
    replacedertThat(this.firestoreTemplate.count(User.clreplaced).block()).isEqualTo(3);
    this.firestoreTemplate.findAll(User.clreplaced).flatMap(a -> {
        a.setAge(a.getAge() - 1);
        return this.firestoreTemplate.save(a);
    }).as(operator::transactional).collectList().block();
    List<User> users = this.firestoreTemplate.findAll(User.clreplaced).collectList().block();
    replacedertThat(users).extracting("age").containsExactlyInAnyOrder(28, 59, 39);
    replacedertThat(users).extracting("name").doesNotContainNull();
    this.firestoreTemplate.deleteAll(User.clreplaced).as(operator::transactional).block();
    replacedertThat(this.firestoreTemplate.findAll(User.clreplaced).collectList().block()).isEmpty();
}

@Test
void usingAnotherDatabaseDeclarativeFromRepo(@Autowired ReactivePersonRepository repository) {
    ReactiveNeo4jTransactionManager otherTransactionManger = new ReactiveNeo4jTransactionManager(driver, ReactiveDatabaseSelectionProvider.createStaticDatabaseSelectionProvider(DATABASE_NAME));
    TransactionalOperator otherTransactionTemplate = TransactionalOperator.create(otherTransactionManger);
    Mono<PersonWithAllConstructor> p = repository.save(new PersonWithAllConstructor(null, "Mercury", "Freddie", "Queen", true, 1509L, LocalDate.of(1946, 9, 15), null, Collections.emptyList(), null, null)).as(otherTransactionTemplate::transactional);
    StepVerifier.create(p).expectErrorMatches(e -> e instanceof IllegalStateException && e.getMessage().equals("There is already an ongoing Spring transaction for 'boom', but you request the default database")).verify();
}

@Test
void usingAnotherDatabaseExplicitTx(@Autowired ReactiveNeo4jClient neo4jClient) {
    TransactionalOperator transactionTemplate = TransactionalOperator.create(neo4jTransactionManager);
    Mono<Long> numberOfNodes = neo4jClient.query("MATCH (n) RETURN COUNT(n)").in(DATABASE_NAME).fetchAs(Long.clreplaced).one().as(transactionTemplate::transactional);
    StepVerifier.create(numberOfNodes).expectErrorMatches(e -> e instanceof IllegalStateException && e.getMessage().equals("There is already an ongoing Spring transaction for the default database, but you request 'boom'")).verify();
}

@RequiredArgsConstructor
@Configuration
public clreplaced C02BookControllerWithR2dbc {

    private static final String PATH_PREFIX = "/routed-r2dbc/";

    private final C01BookRepository bookRepository;

    private final Validator validator;

    private final ObjectMapper objectMapper;

    private final TransactionalOperator transactionalOperator;

    @Bean("r2dbcBookRouter")
    public RouterFunction<ServerResponse> routers() {
        return RouterFunctions.route().POST(PATH_PREFIX + "book", this::create).GET(PATH_PREFIX + "books", this::findAll).GET(PATH_PREFIX + "query-books", this::findByPage).GET(PATH_PREFIX + "book/{isbn}", this::find).PUT(PATH_PREFIX + "book/{isbn}", this::update).DELETE(PATH_PREFIX + "book/{isbn}", this::delete).POST(PATH_PREFIX + "books", this::createMany).build();
    }

    public Mono<ServerResponse> createMany(ServerRequest request) {
        return request.bodyToFlux(Book.clreplaced).flatMap(book -> bookRepository.insert(book)).then(ServerResponse.ok().build()).as(transactionalOperator::transactional);
    }

    private Mono<ServerResponse> findByPage(ServerRequest request) {
        return C04ReactiveControllerHelper.queryParamsToMono(request, objectMapper, BookQuery.clreplaced, validator).flatMap(query -> ServerResponse.ok().body(bookRepository.findBooksByQuery(query), Book.clreplaced));
    }

    private Mono<ServerResponse> delete(ServerRequest request) {
        var isbn = request.pathVariable("isbn");
        return bookRepository.findById(isbn).flatMap(book -> bookRepository.delete(isbn).then(ServerResponse.ok().build())).switchIfEmpty(ServerResponse.notFound().build());
    }

    private Mono<ServerResponse> update(ServerRequest request) {
        var isbn = request.pathVariable("isbn");
        return bookRepository.findById(isbn).flatMap(book -> C04ReactiveControllerHelper.requestBodyToMono(request, validator, Book.clreplaced).flatMap(aBook -> bookRepository.update(aBook).then(ServerResponse.ok().build()))).switchIfEmpty(ServerResponse.notFound().build());
    }

    private Mono<ServerResponse> find(ServerRequest request) {
        var isbn = request.pathVariable("isbn");
        return bookRepository.findById(isbn).flatMap(book -> ServerResponse.ok().bodyValue(book)).switchIfEmpty(ServerResponse.notFound().build());
    }

    private Mono<ServerResponse> findAll(ServerRequest request) {
        return ServerResponse.ok().body(bookRepository.findAll(), Book.clreplaced);
    }

    private Mono<ServerResponse> create(ServerRequest request) {
        return C04ReactiveControllerHelper.requestBodyToMono(request, validator, (t, errors) -> bookRepository.findById(t.getIsbn()).map((book -> {
            errors.rejectValue("isbn", "already.exists", "Already exists");
            return Tuples.of(book, errors);
        })), Book.clreplaced).flatMap(book -> bookRepository.insert(book).thenReturn(book)).flatMap(book -> ServerResponse.created(UriComponentsBuilder.fromHttpRequest(request.exchange().getRequest()).path("/").path(book.getIsbn()).build().toUri()).build());
    }
}

@Component
@Slf4j
@RequiredArgsConstructor
clreplaced DataInitializer implements ApplicationRunner {

    private final DatabaseClient databaseClient;

    private final TransactionalOperator transactionalOperator;

    @Override
    public void run(ApplicationArguments args) throws Exception {
        log.info("start data initialization...");
        transactionalOperator.execute(status -> this.databaseClient.insert().into("posts").value("replacedle", "First post replacedle").value("content", "Content of my first post").map((r, m) -> r.get("id", Integer.clreplaced)).all().log().thenMany(this.databaseClient.select().from("posts").orderBy(Sort.by(desc("id"))).as(Post.clreplaced).fetch().all().log())).subscribe(null, null, () -> log.info("initialization is done..."));
    }
}

@Override
public Single<Resource> create(Resource item) {
    item.setId(item.getId() == null ? RandomString.generate() : item.getId());
    LOGGER.debug("create Resource with id {}", item.getId());
    TransactionalOperator trx = TransactionalOperator.create(tm);
    Mono<Integer> insertResult = dbClient.insert().into(JdbcResource.clreplaced).using(toJdbcEnreplacedy(item)).fetch().rowsUpdated();
    final List<String> resourceScopes = item.getResourceScopes();
    if (resourceScopes != null && !resourceScopes.isEmpty()) {
        insertResult = insertResult.then(Flux.fromIterable(resourceScopes).concatMap(scope -> {
            JdbcResource.Scope rScope = new JdbcResource.Scope();
            rScope.setScope(scope);
            rScope.setResourceId(item.getId());
            return dbClient.insert().into(JdbcResource.Scope.clreplaced).using(rScope).fetch().rowsUpdated();
        }).reduce(Integer::sum));
    }
    return monoToSingle(insertResult.as(trx::transactional)).flatMap((i) -> this.findById(item.getId()).toSingle()).doOnError((error) -> LOGGER.error("unable to create Resource with id {}", item.getId(), error));
}

@Override
public Single<Organization> create(Organization organization) {
    organization.setId(organization.getId() == null ? RandomString.generate() : organization.getId());
    LOGGER.debug("create organization with id {}", organization.getId());
    TransactionalOperator trx = TransactionalOperator.create(tm);
    Mono<Void> insert = dbClient.insert().into(JdbcOrganization.clreplaced).using(toJdbcOrganization(organization)).then();
    final Mono<Void> storeIdenreplacedies = storeIdenreplacedies(organization, false);
    final Mono<Void> storeDomainRestrictions = storeDomainRestrictions(organization, false);
    final Mono<Void> storeHrids = storeHrids(organization, false);
    return monoToSingle(insert.then(storeIdenreplacedies).then(storeDomainRestrictions).then(storeHrids).as(trx::transactional).then(maybeToMono(findById(organization.getId()))));
}

@Override
public Single<Environment> update(Environment environment) {
    LOGGER.debug("update environment with id {}", environment.getId());
    TransactionalOperator trx = TransactionalOperator.create(tm);
    // prepare the update for environment table
    Mono<Void> update = dbClient.update().table(JdbcEnvironment.clreplaced).using(toJdbcEnvironment(environment)).matching(from(where("id").is(environment.getId()))).then();
    return monoToSingle(update.then(storeDomainRestrictions(environment, true)).then(storeHrids(environment, true)).as(trx::transactional).then(maybeToMono(findById(environment.getId()))));
}

@Override
public Single<Environment> create(Environment environment) {
    environment.setId(environment.getId() == null ? RandomString.generate() : environment.getId());
    LOGGER.debug("create Environment with id {}", environment.getId());
    TransactionalOperator trx = TransactionalOperator.create(tm);
    Mono<Void> insert = dbClient.insert().into(JdbcEnvironment.clreplaced).using(toJdbcEnvironment(environment)).then();
    final Mono<Void> storeDomainRestrictions = storeDomainRestrictions(environment, false);
    final Mono<Void> storeHrids = storeHrids(environment, false);
    return monoToSingle(insert.then(storeDomainRestrictions).then(storeHrids).as(trx::transactional).then(maybeToMono(findById(environment.getId()))));
}

@Override
public Single<Domain> create(Domain item) {
    item.setId(item.getId() == null ? RandomString.generate() : item.getId());
    LOGGER.debug("create Domain with id {}", item.getId());
    TransactionalOperator trx = TransactionalOperator.create(tm);
    Mono<Integer> insertAction = dbClient.insert().into(JdbcDomain.clreplaced).using(toJdbcDomain(item)).fetch().rowsUpdated();
    insertAction = persistChildEnreplacedies(insertAction, item);
    return monoToSingle(insertAction.as(trx::transactional)).flatMap((i) -> this.findById(item.getId()).toSingle()).doOnError((error) -> LOGGER.error("unable to create domain with id {}", item.getId(), error));
}

@Test
public void triggerRollbackCorrectly() {
    FirestoreTemplate template = getFirestoreTemplate();
    ReactiveFirestoreTransactionManager txManager = new ReactiveFirestoreTransactionManager(this.firestoreStub, this.parent, this.clreplacedMapper);
    TransactionalOperator operator = TransactionalOperator.create(txManager);
    template.findById(Mono.defer(() -> {
        throw new FirestoreDataException("BOOM!");
    }), FirestoreTemplateTests.TestEnreplacedy.clreplaced).as(operator::transactional).as(StepVerifier::create).expectError().verify();
    verify(this.firestoreStub, times(1)).beginTransaction(any(), any());
    verify(this.firestoreStub, times(0)).commit(any(), any());
    verify(this.firestoreStub, times(1)).rollback(any(), any());
}

@Test
void usingSameDatabaseExplicitTx(@Autowired ReactiveNeo4jClient neo4jClient) {
    ReactiveNeo4jTransactionManager otherTransactionManger = new ReactiveNeo4jTransactionManager(driver, ReactiveDatabaseSelectionProvider.createStaticDatabaseSelectionProvider(DATABASE_NAME));
    TransactionalOperator otherTransactionTemplate = TransactionalOperator.create(otherTransactionManger);
    Mono<Long> numberOfNodes = neo4jClient.query(TEST_QUERY).in(DATABASE_NAME).fetchAs(Long.clreplaced).one().as(otherTransactionTemplate::transactional);
    StepVerifier.create(numberOfNodes).expectNext(1L).verifyComplete();
}

@Test
void idGenerationWithNewEnreplacedyShouldWork(@Autowired ThingWithGeneratedIdRepository repository) {
    List<ThingWithGeneratedId> savedThings = new ArrayList<>();
    TransactionalOperator transactionalOperator = TransactionalOperator.create(transactionManager);
    transactionalOperator.execute(t -> repository.save(new ThingWithGeneratedId("WrapperService"))).as(StepVerifier::create).recordWith(() -> savedThings).consumeNextWith(savedThing -> {
        replacedertThat(savedThing.getName()).isEqualTo("WrapperService");
        replacedertThat(savedThing.getTheId()).isNotBlank().matches("thingWithGeneratedId-\\d+");
    }).verifyComplete();
    verifyDatabase(savedThings.get(0).getTheId(), savedThings.get(0).getName());
}

@Test
void shouldNotOverwriteExistingId(@Autowired ThingWithGeneratedIdRepository repository) {
    Mono<ThingWithGeneratedId> findAndUpdateAThing = repository.findById(ID_OF_EXISTING_THING).flatMap(thing -> {
        thing.setName("changed");
        return repository.save(thing);
    });
    List<ThingWithGeneratedId> savedThings = new ArrayList<>();
    TransactionalOperator transactionalOperator = TransactionalOperator.create(transactionManager);
    transactionalOperator.execute(t -> findAndUpdateAThing).as(StepVerifier::create).recordWith(() -> savedThings).consumeNextWith(savedThing -> {
        replacedertThat(savedThing.getName()).isEqualTo("changed");
        replacedertThat(savedThing.getTheId()).isEqualTo(ID_OF_EXISTING_THING);
    }).verifyComplete();
    verifyDatabase(savedThings.get(0).getTheId(), savedThings.get(0).getName());
}

@Test
void idGenerationWithNewEnreplacediesShouldWork(@Autowired ThingWithGeneratedIdRepository repository) {
    List<ThingWithGeneratedId> things = IntStream.rangeClosed(1, 10).mapToObj(i -> new ThingWithGeneratedId("name" + i)).collect(toList());
    Set<String> generatedIds = new HashSet<>();
    TransactionalOperator transactionalOperator = TransactionalOperator.create(transactionManager);
    transactionalOperator.execute(t -> repository.saveAll(things)).map(ThingWithGeneratedId::getTheId).as(StepVerifier::create).recordWith(() -> generatedIds).expectNextCount(things.size()).expectRecordedMatches(recorded -> {
        replacedertThat(recorded).hreplacedize(things.size()).allMatch(generatedId -> generatedId.matches("thingWithGeneratedId-\\d+"));
        return true;
    }).verifyComplete();
}

@Test
void idGenerationByBeansShouldWorkWork(@Autowired ThingWithIdGeneratedByBeanRepository repository) {
    List<ThingWithIdGeneratedByBean> savedThings = new ArrayList<>();
    TransactionalOperator transactionalOperator = TransactionalOperator.create(transactionManager);
    transactionalOperator.execute(t -> repository.save(new ThingWithIdGeneratedByBean("WrapperService"))).as(StepVerifier::create).recordWith(() -> savedThings).consumeNextWith(savedThing -> {
        replacedertThat(savedThing.getName()).isEqualTo("WrapperService");
        replacedertThat(savedThing.getTheId()).isEqualTo("ReactiveID.");
    }).verifyComplete();
    verifyDatabase(savedThings.get(0).getTheId(), savedThings.get(0).getName());
}

@Override
public Single<User> create(User item) {
    item.setId(item.getId() == null ? RandomString.generate() : item.getId());
    LOGGER.debug("Create user with id {}", item.getId());
    TransactionalOperator trx = TransactionalOperator.create(tm);
    DatabaseClient.GenericInsertSpec<Map<String, Object>> insertSpec = dbClient.insert().into("users");
    // doesn't use the clreplaced introspection to handle json objects
    insertSpec = addQuotedField(insertSpec, "id", item.getId(), String.clreplaced);
    insertSpec = addQuotedField(insertSpec, "external_id", item.getExternalId(), String.clreplaced);
    insertSpec = addQuotedField(insertSpec, "username", item.getUsername(), String.clreplaced);
    insertSpec = addQuotedField(insertSpec, "email", item.getEmail(), String.clreplaced);
    insertSpec = addQuotedField(insertSpec, "display_name", item.getDisplayName(), String.clreplaced);
    insertSpec = addQuotedField(insertSpec, "nick_name", item.getNickName(), String.clreplaced);
    insertSpec = addQuotedField(insertSpec, "first_name", item.getFirstName(), String.clreplaced);
    insertSpec = addQuotedField(insertSpec, "last_name", item.getLastName(), String.clreplaced);
    insertSpec = addQuotedField(insertSpec, "replacedle", item.getreplacedle(), String.clreplaced);
    insertSpec = addQuotedField(insertSpec, "type", item.getType(), String.clreplaced);
    insertSpec = addQuotedField(insertSpec, "preferred_language", item.getPreferredLanguage(), String.clreplaced);
    insertSpec = addQuotedField(insertSpec, "account_non_expired", item.isAccountNonExpired(), Boolean.clreplaced);
    insertSpec = addQuotedField(insertSpec, "account_locked_at", dateConverter.convertTo(item.getAccountLockedAt(), null), LocalDateTime.clreplaced);
    insertSpec = addQuotedField(insertSpec, "account_locked_until", dateConverter.convertTo(item.getAccountLockedUntil(), null), LocalDateTime.clreplaced);
    insertSpec = addQuotedField(insertSpec, "account_non_locked", item.isAccountNonLocked(), Boolean.clreplaced);
    insertSpec = addQuotedField(insertSpec, "credentials_non_expired", item.isCredentialsNonExpired(), Boolean.clreplaced);
    insertSpec = addQuotedField(insertSpec, "enabled", item.isEnabled(), Boolean.clreplaced);
    insertSpec = addQuotedField(insertSpec, "internal", item.isInternal(), Boolean.clreplaced);
    insertSpec = addQuotedField(insertSpec, "pre_registration", item.isPreRegistration(), Boolean.clreplaced);
    insertSpec = addQuotedField(insertSpec, "registration_completed", item.isRegistrationCompleted(), Boolean.clreplaced);
    insertSpec = addQuotedField(insertSpec, "newsletter", item.isNewsletter(), Boolean.clreplaced);
    insertSpec = addQuotedField(insertSpec, "registration_user_uri", item.getRegistrationUserUri(), String.clreplaced);
    insertSpec = addQuotedField(insertSpec, "registration_access_token", item.getRegistrationAccessToken(), String.clreplaced);
    insertSpec = addQuotedField(insertSpec, "reference_type", item.getReferenceType(), String.clreplaced);
    insertSpec = addQuotedField(insertSpec, "reference_id", item.getReferenceId(), String.clreplaced);
    insertSpec = addQuotedField(insertSpec, "source", item.getSource(), String.clreplaced);
    insertSpec = addQuotedField(insertSpec, "client", item.getClient(), String.clreplaced);
    insertSpec = addQuotedField(insertSpec, "logins_count", item.getLoginsCount(), Integer.clreplaced);
    insertSpec = addQuotedField(insertSpec, "logged_at", dateConverter.convertTo(item.getLoggedAt(), null), LocalDateTime.clreplaced);
    insertSpec = addQuotedField(insertSpec, "created_at", dateConverter.convertTo(item.getCreatedAt(), null), LocalDateTime.clreplaced);
    insertSpec = addQuotedField(insertSpec, "updated_at", dateConverter.convertTo(item.getUpdatedAt(), null), LocalDateTime.clreplaced);
    insertSpec = databaseDialectHelper.addJsonField(insertSpec, "x509_certificates", item.getX509Certificates());
    insertSpec = databaseDialectHelper.addJsonField(insertSpec, "factors", item.getFactors());
    insertSpec = databaseDialectHelper.addJsonField(insertSpec, "additional_information", item.getAdditionalInformation());
    Mono<Integer> insertAction = insertSpec.fetch().rowsUpdated();
    insertAction = persistChildEnreplacedies(insertAction, item);
    return monoToSingle(insertAction.as(trx::transactional)).flatMap((i) -> this.findById(item.getId()).toSingle()).doOnError((error) -> LOGGER.error("Unable to create user with id {}", item.getId(), error));
}

@Override
public Single<Group> create(Group item) {
    item.setId(item.getId() == null ? RandomString.generate() : item.getId());
    LOGGER.debug("create Group with id {}", item.getId());
    TransactionalOperator trx = TransactionalOperator.create(tm);
    DatabaseClient.GenericInsertSpec<Map<String, Object>> insertSpec = dbClient.insert().into(quoted("groups"));
    insertSpec = addQuotedField(insertSpec, "id", item.getId(), String.clreplaced);
    insertSpec = addQuotedField(insertSpec, "reference_id", item.getReferenceId(), String.clreplaced);
    insertSpec = addQuotedField(insertSpec, "reference_type", item.getReferenceType() == null ? null : item.getReferenceType().name(), String.clreplaced);
    insertSpec = addQuotedField(insertSpec, "name", item.getName(), String.clreplaced);
    insertSpec = addQuotedField(insertSpec, "description", item.getDescription(), String.clreplaced);
    insertSpec = addQuotedField(insertSpec, "created_at", dateConverter.convertTo(item.getCreatedAt(), null), LocalDateTime.clreplaced);
    insertSpec = addQuotedField(insertSpec, "updated_at", dateConverter.convertTo(item.getUpdatedAt(), null), LocalDateTime.clreplaced);
    Mono<Integer> action = insertSpec.fetch().rowsUpdated();
    action = persistChildEnreplacedies(action, item);
    return monoToSingle(action.as(trx::transactional)).flatMap((i) -> this.findById(item.getId()).toSingle()).doOnError((error) -> LOGGER.error("unable to create group with id {}", item.getId(), error));
}

See More Examples