[question] How fast is it on Agile?

[leonardomarcao]

Hi Álefe, how are you?

Congratulations on the repository, this project is beautiful and applies good modern practices.

I have a question, in your opinion, how fast is the usage of this structure/architecture project developing a small/medium project size?

For example, imagine I want to add a new entity called Order, what is the flow, and how much time will be spent to develop this? Of course, this depends on more detailed context and I apologize for this, but consider this question generic.

[alefeans]

Hi @leonardomarcao, I apologize for the delay and hope you're doing well!

Thanks for the feedback and for expressing your interest in pycommerce, I appreciate it! Now, to your questions:

I have a question, in your opinion, how fast is the usage of this structure/architecture project developing a small/medium project size?

For example, imagine I want to add a new entity called Order, what is the flow, and how much time will be spent to develop this? Of course, this depends on more detailed context and I apologize for this, but consider this question generic.

For small projects, this structure is definitely an overkill. You'll lose too much time dealing with all levels of indirection, and the benefit won't pay off if the project doesn't grow, so don't bother with it if that's your case. You can benefit from a less formal structure with fewer layers and still have a good level of independence between them if you keep the discipline and consistency to maintain it organized and decoupled.

In terms of development speed for medium and large-sized projects, the initial setup time can be consuming. However, after implementing the first use case, the subsequent ones will be quick as the structure is already in place as a starting point. It took me a little less than an hour to implement all the layers (tests included) for the Category entity, as I already had implemented them for the User entity.

Regarding the development flow, a good framework to follow is to work from the inside out. For example (ignoring the tests):

1. Entity data modeling
2. DTO data modeling
3. Protocols definition (i.e. the interfaces that will be used by the use cases)
4. Use case implementation
5. Protocols implementation (e.g. repository layer, db entities, etc)
6. API endpoint definition, etc

Let me know if my answer makes sense to you and feel free to ask me more questions!

[leonardomarcao]

Thank you for answer my question and clarify my mind.

So, I decided to use your project making some adaptations, look the currently structure:

├── alembic.ini
├── app
│   ├── api
│   │   ├── dependencies
│   │   │   ├── address.py
│   │   │   ├── auth.py
│   │   │   ├── blog.py
│   │   │   ├── company.py
│   │   │   ├── crypto.py
│   │   │   ├── document.py
│   │   │   ├── __init__.py
│   │   │   ├── jwt.py
│   │   │   ├── mail_service.py
│   │   │   ├── s3_service.py
│   │   │   ├── tenant.py
│   │   │   ├── user.py
│   │   │   └── vehicle.py
│   │   ├── extensions.py
│   │   ├── __init__.py
│   │   ├── middleware
│   │   │   ├── exceptions.py
│   │   │   ├── __init__.py
│   │   │   ├── query_params.py
│   │   │   └── tenant.py
│   │   └── routers
│   │       ├── __init__.py
│   │       ├── root.py
│   │       └── v1
│   ├── application
│   │   ├── config.py
│   │   ├── data
│   │   │   └── default_data.json
│   │   ├── dto
│   │   │   ├── __init__.py
│   │   │   └── paginate.py
│   │   ├── entities
│   │   │   ├── base.py
│   │   │   ├── enum
│   │   │   └── __init__.py
│   │   ├── exceptions
│   │   │   ├── address.py
│   │   │   ├── auth.py
│   │   │   ├── base.py
│   │   │   ├── blog.py
│   │   │   ├── company.py
│   │   │   ├── document.py
│   │   │   ├── tenant.py
│   │   │   ├── user.py
│   │   │   └── vehicle.py
│   │   ├── i18n
│   │   │   └── exceptions.json
│   │   ├── __init__.py
│   │   ├── interfaces
│   │   │   ├── crypto.py
│   │   │   ├── __init__.py
│   │   │   ├── jwt.py
│   │   │   ├── mail_service.py
│   │   │   ├── repositories
│   │   │   ├── s3.py
│   │   │   └── unit_of_work.py
│   │   └── setup.py
│   ├── domain
│   │   ├── address
│   │   │   ├── city
│   │   │   ├── country
│   │   │   ├── dto.py
│   │   │   ├── entities.py
│   │   │   ├── __init__.py
│   │   │   ├── state
│   │   │   └── usecases.py
│   │   ├── blog
│   │   │   ├── dto.py
│   │   │   ├── entities.py
│   │   │   ├── __init__.py
│   │   │   └── usecases.py
│   │   ├── company
│   │   │   ├── dto.py
│   │   │   ├── entities.py
│   │   │   ├── __init__.py
│   │   │   └── usecases.py
│   │   ├── document
│   │   │   ├── dto.py
│   │   │   ├── entities.py
│   │   │   ├── __init__.py
│   │   │   └── usecases.py
│   │   ├── __init__.py
│   │   ├── tenant
│   │   │   ├── dto.py
│   │   │   ├── entities.py
│   │   │   ├── __init__.py
│   │   │   └── usecases.py
│   │   ├── user
│   │   │   ├── dto.py
│   │   │   ├── entities.py
│   │   │   ├── __init__.py
│   │   │   └── usecases.py
│   │   └── vehicle
│   │       ├── advertisement
│   │       ├── brand
│   │       ├── category
│   │       ├── dto.py
│   │       ├── entities.py
│   │       ├── feature
│   │       ├── __init__.py
│   │       ├── model
│   │       └── usecases.py
│   ├── infra
│   │   ├── common
│   │   │   ├── application.py
│   │   │   ├── __init__.py
│   │   │   └── resize_image.py
│   │   ├── db
│   │   │   ├── __init__.py
│   │   │   ├── models
│   │   │   ├── repositories
│   │   │   └── unit_of_work
│   │   ├── __init__.py
│   │   ├── providers
│   │   │   ├── crypto.py
│   │   │   ├── data_validation.py
│   │   │   ├── __init__.py
│   │   │   ├── jwt.py
│   │   │   ├── mail.py
│   │   │   └── s3.py
│   │   └── templates
│   │       └── mail
│   ├── __init__.py
│   └── __main__.py
├── docker-compose.yml
├── Dockerfile
├── docs
├── heroku.yml
├── package-lock.json
├── poetry.lock
├── README.md
├── scripts
│   └── init.sql
└── start-dev.sh

I can consider this small today, but it's a whitelabel project that'll be grow-up after some time.

It's working 100%!

Thank you my friend.

[alefeans]

That's awesome! At first, I was tempted to follow something similar to what you did in the domain layer, but I decided to go with the current implementation.

Would you mind explaining the role of the application layer?