Feature Request: Use schematics for project transformations

sis0k0 commented 6 years ago

What is `Schematics`?

Schematics is a workflow tool for project transformations, such as scaffolding, file updates and tasks execution (npm install, git init). It can apply rules* from predefined collections - for example generate a new Angular project using the @schematics/angular collection or set up Kendo UI using the @progress/kendo-schematics collection.

* rules - should also be called schematics, but that's confusing, so I'll stick to the name rules instead.

Who uses `Schematics`?

Schematics is extensively used inside the Angular CLI. It's the backbone of the commands:

ng new - generates the files for a new Angular project, initializes a git repository and installs the node dependencies. It supports a large range of options, such as routing - whether routing configuration should be generated, styling - what css preprocessor should be used, skipTests - whether test setup should be generated, etc.
ng generate - performs project transformations using a provided rule name and collection.
ng add - installs a plugin and executes the setup logic provided by the plugin. For example - ng add @nativescript/schematics converts the project to a code-sharing structure by adding all necessary NativeScript dependencies and the minimal setup for running a mobile app.

How can `Schematics` be used in the NativeScript CLI?

1. `tns generate`

Create a command that behaves similarly to ng generate. The @nativescript/schematics collection can be extended with non-Angular rules (Vue.js, plain NativeScript). This will allow all NativeScript developers to use schematics in their projects.

2. `tns plugin add`

There is already a tns plugin add command in NativeScript CLI, which installs NativeScript plugins and performs project modifications. With schematics, the NativeScript CLI can:

Perform the project modifications. The advantage over the current implementation is that with Schematics all changes are recorded in memory and are executed only after they're confirmed to be valid. In other words - if the command fails, no changes will be applied to the project.
Execute setup rules distributed by the plugins, similarly to ng add. This will simplify the setup of plugins which currently rely on executing postinstall scripts, such as nativescript-dev-webpack and nativescript-plugin-firebase. It will also allow every NativeScript plugin to add a rule to automate the setup of the plugin. For example, the nativescript-pro-ui plugin will be able to provide a rule, which imports its NgModule in the root NgModule if the project uses Angular.

3. `tns create`

Schematics provides a powerful template engine. The NativeScript templates can be turned into schematic rules. The benefits:

a lot of the common parts (such as package.json) will be reused;
new project options will be trivial to add (routing, style, sidedrawer, tabview, etc.);
the rules will be hosted in a monorepo instead of separated repos for each template.

Also, the NativeScript CLI will be able to perform tasks, similarly to the Angular CLI - it could initialize a git repository for the project, install the project dependencies, etc.

Please share your feedback in the comments!

vakrilov commented 6 years ago

Few more points and additions:

4. Extensibility

If played out right, the community should be able to contribute with schematics that will add functionality to (1. tns generate) and (3. tns create).

5. `tns update`

Updating dependencies, migrating code, handling breaking changes between versions can also be done with schematics in a robust and transactional manner.

Some things that we should consider:

How big is it? Will the additional dependencies will increase the size of the CLI considerably? (@sis0k0)
If we decide that it is worth a try - which would be the best place to integrate it first? (@rosen-vladimirov)

rosen-vladimirov commented 5 years ago

NativeScript / nativescript-cli