Getting Started

Prerequisites

We're using ES6 features! Which means you gonna need to compile your code to work with some NodeJs versions. Thankfully, there's a lot of tools out there doing that, such as babel.

You might also want to work with TypeScript. If you do, check the experimental decorators support option to start coding.

To guarantee you're gonna load only what you want and need, Appt is fully modular and uncoupled by scoped packages. These are the other packages you might wanna use:

Packages

@appt/core

This package is the main dependency of our framework. With it, you can start your NodeJs application and scale it on a non-intrusive/non-imperative way by maintaining everything over a Dependency Injection Pattern working together with a Module/Component abstraction provided by Appt.

@appt/api

A ready-to-go wrapper to build amazing API's that gathers essential tools, such as express, body-parser and express-jwt, putting them all into Appt's ecosystem.

@appt/mongoose

A wrapper to put mongoose inside the Appt's ecosystem and make it works on crack!

@appt/cli

A simple cli for Appt projects seed generation (until now)

@appt/legacy

That was a first implementation of Appt concept. It's not maintained anymore, but it's stable and has this value on a non-class-orientation approach. If you feel curious about it, maybe it's worth to check it out.

Features

Thanks to ES6 features, Appt's core help your development process, being less intrusive.

Path Heaven

Imagine yourself starting a new project, which you don't really sure about the architecture. You'll write some code, import packages and classes by their paths when suddenly BOOM: you decide to reorganize everything. You're gonna rewrite every ../../../../path of every single file into your project.

...Or maybe, you're on a complex project, which becomes bigger and bigger fast, and the more it grows, the more impossible becomes to read and find yourself on it.

If some of those scenarios looks familiar and bother you, you should definitely use Appt!

Dependecy Injection

The whole Appt's ecosystem is based on dependecy injection pattern, using the power of decorators over the annotation sintaxe style (AtScript). This allows Appt's core to be more flexible and scale your application easier without being a lot imperative.

Modules && Components

EVERYTHING on Appt's concept is about to build applications over the perception of Modules and Components. Inside @appt/core, these concepts are implemented as @Module and @Component decorators, which have the purpose to assemble the whole application and handle the implementation's logic, respectively. That means, you can naturally build your application as you always do (building your custom middlewares, server, database connections and so on...) and let Appt to wrap it all with simplicity on a non-intrusive style.

Special-Type Extenders

Even the main core decorators @Module and @Component have particular and simple roles, Appt also provides a way to add some powers and behaviours to them, making use of Special-Type Extenders. That means, even you do not need them, they can give an elegant, semantic and straightforward approach to your server implementation, database connection, routes etc.

Configurations

Because we are also talking about to create ready-to-go NodeJs applications, every Special-Type Extender has its default configuration. That means Appt can overcome some trivial steps on development process, such as writing CORS, defining Body Parsers, making JWT middlewares, configuring Routers etc, by simply providing built-in default configuration and, of course, letting you overwrite them. If you do, you can handle those configs using @appt/core/config or just do it on your own.