creating the architecture for quick cli init

[jeffotoni]

Now the next step is to get the commands to actually work.

• quick init → create the structure of a Quick project
• quick addc → add controller (e.g. quick addc user)
• quick template → commands: list, add, use
• quick ui → run the TUI using Bubble Tea (we'll leave the last ones for last, only when everything is well advanced and tested and its use is confirmed.

Now when creating the functionality, for example quick init, we'll have to create _test.go, we'll have to document it in the README to keep it, otherwise it will turn into a giant snowball and we won't be able to handle it.

Let's start at the beginning, with init defining the minimum structure that we can create for the project using Quick.

go run main.go init --help
Initialize a new Quick project with the basic structure.
You can specify a name for the project or use the current directory.

Examples:
quick init my-project
quick init --template api my-project

Usage:
quick init [project-name] [flags]

Flags:
-h, --help help for init
-t, --template string Template to be used (default, api, web) (default "default")

Global Flags:
--config string config file (defaults to $HOME/.quick.yaml)

Now we have to define the content and architecture we want for the files.

I set it to start with:
default
Web
Cli

But we can have:
microservices
Lambda aws
Google Functions
etc.

Now let's define the architecture for default, web and CLI.

In other words, if we were to develop a web project, what would the minimum structure be like, such as quick, and if we were to develop an API, what would it be like? And if we were to create a CLI, what would it be like?

Let's start with the default and API, which is much easier for us.

I was thinking that DEFAULT = API .

And there are also template models in init, to make it even more robust.

Check everything carefully, now the fun begins.

[emmadal]

I'm Ok for that. Default = API it's good in other word user will specify the flag --web to have a web project. Ok.

[emmadal]

Hello @jeffotoni ,
I have an idea, but i want to discuss with you if it's a good approach. by analyzing, when user will create a quick project from scratch, i think we can use the examples folder to store some folder of template or example of strucuture to genereate the app.

by example, when user will do this quick init or quick init myproject, in the examples folder we can have a simple folder called bootstrap or start or something else which will handle the basic structure of default quick app based on this structure:

my-project/
├── cmd/
│   └── server/
│       └── main.go
├── internal/
│   ├── config/
│   │   └── config.go
│   ├── controllers/
│   │   └── home.go
│   ├── models/
│   │   └── user.go
├── pkg/
│   └── utils/
│       └── utils.go
├── .gitignore
├── go.mod
├── go.sum
└── README.md

and the content of this basic example will be copied inside the new project name.

what do you think ?