clean-architecture | A guide to the methodology behind Made | Architecture library

I had this problem.

Change beforeEach to beforeAll and afterEach to afterAll. I'm not 100% sure but I'd argue that this is caused by the registration of new connections when beforeEach is called so even though you are destroying the connection in afterEach, it is still registered.

We 'got something working' ... not elegant but does the job.

Gotcha - there is no way my colleagues and I discovered of using SelectMany using main implementation, which is needed when getting arrays from separate collections e.g. in SQL world:

In class GetRandomNumberTrivia I added typing NumberTriviaRepository for the field repository and the code compiled.

I would create a progress interface in the use case layer, since it reports progress of the use case.

Then I would implement a progress presenter and pass it to the use case when it is called from the controller.

The use case can then pass the progress to the payment terminal adapter through it's interface.

To enable Google to crawl your app content and allow users to enter your app from search results, you must add intent filters for the relevant activities in your app manifest. These intent filters allow deep linking to the content in any of your activities. For example, the user might click on a deep link to view a page within a shopping app that describes a product offering that the user is searching for.

this is the first reason and the second one is

ACTION_VIEW Use this action in an intent with startActivity() when you have some information that an activity can show to the user, such as a photo to view in a gallery app, or an address to view in a map app.

while The ACTION_MAIN action indicates this is the main entry point and does not expect any intent data. so activity can have both

I solved it, I just needed to add the event to the bloc. So, my solution was to create another state called PaintingsInitialState like so:

The States

Finally I had to add use_frameworks! :linkage => :static and all my problems are gone :)

I have a feeling this question is better suited to Software Engineering SE but I will make an attempt at answering.

The short answer to your question is: Yes.

If you want to follow Clean Architecture to the letter, the thing to do is build domain models that don't depend on your persistence layer at all. With gorm, that necessitates building a domain <-> persistence model mapping layer and all the added complexity that comes from that. Gorm will still make querying and saving that persistence model easier than creating your own queries, and compared to ORMs in other languages that I've experienced, it's still fairly lightweight.

Technically you do not need to have gorm.Model in the model structs. Having an ID int field, plus any of the CreatedAt, UpdatedAt, DeletedAt fields that you want is enough (this is what gorm.Model gives you). But invariably you will be adding other artifacts that are to do with how gorm does things, so you do not escape this dependence if the gorm package isn't present in your model structs.

This begs the question of whether following Clean Arch to the letter is the right decision for your project. Like all design decisions, it bears tradeoffs and makes more or less sense according to the scope and complexity of the system being built. If you foresee challenges that your project will run into that Clean Arch can mitigate then the extra investment now will pay off. If, on the other hand, aspects of the architecture are there to mitigate problems you're unlikely to run into in your particular situation, then you may be more forgiving. The conclusion to the blog post you linked makes an argument along the same lines:

NHibernate provides the best set of trade-offs between the implementation complexity and the overall purity. There still will be ORM concerns leaking into your domain model, however. But I think it’s a low price for all the benefits you’ll get out of it: speed of development, rich functionality, and separation of concerns.

You use interfaces to be able to change implementations without modifiying your code.

If in a future you use another "way" of sending mails, you just need to change the IMailSender implementation and that's all. Otherwise you would need to refactor all your code depending on your MailSender implementation.

Normally you would use your IMailSender interface also in your validation project. So yes, this intertface should reside in a common library, which will be referenced by both libraries.

Then you will inject (normally via IoC) the implementation in your services, which depend on IMailSender

Usually your Infrastructure library will have have the implementations of your interfaces (some of them may be declared in your "core" library and others...) which will be injected in the classes using it.

So the "infrastructure library" is a way to abstract you implementations, so your code soes not rely on specific classes but on interfaces, being way easier to refactor/change in a future.

There are some other points (it also depends if you are using DDD etc..here every Domain has its own infrastructure) but for me this is the main "reason" of an infrastructure layer.

In this case I would not duplicate the interface, as long as you need the same functionality in both libraries. If not the case, then create two interfaces, each serving the specific needs.