Huge News!Announcing our $40M Series B led by Abstract Ventures.Learn More
Socket
Sign inDemoInstall
Socket

@appolo/engine

Package Overview
Dependencies
Maintainers
2
Versions
24
Alerts
File Explorer

Advanced tools

Socket logo

Install Socket

Detect and block malicious and high-risk dependencies

Install

@appolo/engine

nodejs server framework

  • 8.0.26
  • latest
  • Source
  • npm
  • Socket score

Version published
Maintainers
2
Created
Source

Appolo-Engine

Build Status Dependencies status NPM version npm Downloads Known Vulnerabilities

appolo

Appolo is an light web server MVC Framework for Node.js written in Typescript
Appolo architecture follows common patten of MVC and dependency injection which makes it easy to build better performance, flexibility and easy maintenance server side in nodejs.

Features

  • Super fast
  • MVC Architecture
  • Dependency injection
  • Routes validation
  • Modules system
  • Manage easily configurations and environments
  • Simple folder structures
  • Easy to get started

Installation

npm install @appolo/engine --save

Typescript

appolo requires TypeScript compiler version > 2.1 and the following settings in tsconfig.json:

{
	"experimentalDecorators": true
}

Quick Start

In your app.js file:

var {createApp}  from '@appolo/engine';
createApp().launch();

Directory Structure

Appolo will require all files in the config and src folders, but the env folder will be loaded first. All other folders are optional

|- config
    |- env
        |- all.ts
        |- development.ts
        |- production.ts

	|- modules
	    |- all.ts
|- src
    |- controllers
    |- managers
    |- services
    |- bootstrap.ts
    |- app.ts

Configuration

appolo launch configuration options, all options are optional

keyDescriptionTypeDefault
pathsfolders that will be required and loaded on appolo launcharray[ 'src']
environmentenvironment file name that will override the settings in environments/all.jsstring`(process.env.NODE_ENV
usage example:
import {createApp}  from '@appolo/engine';
(async ()=>{
    let app = await createApp({
        paths:[ 'src'],
        root : process.cwd()+'/app',
        environment : 'testing'
     }).launch();
 })();

Environments

With environments you can define different configurations depending on the environment type your app is currently running. It is recommended to have 4 types of environments: development, testing, staging, production. After appolo.launch you can always access the current environment vars via appolo.environment.

//all.ts
export = {
  name:'all',
  someVar:'someVar'
}
//development.ts
export = {
  name:'develpment',
  db:'mongo://development-url'
}
//development.ts
export = {
  name:'testing',
  db:'mongo://testing-url'
}

If we launch our app.js with NODE_ENV = testing

import {createApp}  from '@appolo/engine';
...
let app = await createApp().launch();
var env = appolo.env;
console.log(env.name,env.someVar,env.db) // 'testing someVar monog:://testing-url'

Dependency Injection System

Appolo has a powerful Dependency Injection system based on appolo-inject. It enables you to write organised, testable code based on the loose coupling idea. You can always access the injector via app.injector.

class decorators

  • define - make the object injectable
  • singleton - the class will be created only once and the injector will return the same instance every time
  • lazy - wait for the class to be injected before creating it
  • alias - add alias name to the object (allows injecting multiple objects which share an alias using injectAlias)
  • aliasFactory - add alias factory name to the object (allows injecting multiple objects which share an alias using injectAliasFactory)

methods decorators

  • initMethod - The method will be called after all instances were created and all the properties injected.

property decorators

method parameter decorators

  • injectParam - inject object by parameter
//dataRemoteManager.ts
import {define,singleton,initMethod,inject,IFactory,factory} from '@appolo/inject';
@define()
@singleton()
export class DataRemoteManager {
    getData(){ ...}
}
//dataManager.ts
@define()
@singleton()
@factory()
export class DataManager implement IFactory {
    @inject() dataRemoteManager:DataRemoteManager

    get(){
        return this.dataRemoteManager;
    }
}
//fooController.ts
@controller()
export class FooController{
    @inject() dataManager:DataManager
    constructor() {
        this.data = null
    }

    @initMethod()
    initialize(){
        this.data =  this.dataManager.getData();
    }

    @get("/data")
    getData(){
        return this.data;
    }
}

You can also use constructor injection or method parameter injection:

import {define,singleton,injectParam,initMethod,inject} from '@appolo/inject';
@define()
@singleton()
export class DataManager {
    getData(){ ... }
}
@define()
class FooController{
    constructor(@injectParam() dataManager:DataManager) {
        this.dataManager = dataManager;
    }

    @initMethod()
    public initialize(){
        this.data =  this.dataManager.getData();
    }

    public test(@injectParam() logger:Logger){... }
}

Inherited injections

Inherited injections are supported as well. Anything you inject on a base class will be available to child classes. Remember not to use @define on the parent class.

import {define,singleton,injectParam,initMethod,inject} from '@appolo/inject';

export class BaseManager {
    @inject() protected env:any
    private getData(){...}
}

@define()
class FooManager extends BaseManager{
    @initMethod()
    public initialize(){
        //the env object in injected from the base class
        console.log(this.env.test)
    }
}

Event Dispatcher

Appolo has a built-in event dispatcher to enable classes to listen to and fire events. Event Dispatcher has the following methods:

import {define,singleton,injectParam,initMethod,inject} from '@appolo/inject';
import {EventDispatcher} from '@appolo/events';
@define()
@singleton()
export class FooManager extends EventDispatcher{
    public notifyUsers(){
        this.fireEvent('someEventName',{someData:'someData'})
    }
}
@define()
export class FooController {
    @inject() fooManager:FooManager;
    @initMethod()
    public initialize(){
        this.fooManager.on('someEventName',(data)=>{
            this.doSomething(data.someData)
        },this);
    }
    doSomething(data){...}
}

Modules

Third party modules can be easily loaded intto appolo inject and used in the inject container. Each module must call appolo.module before it can be used by appolo launcher. appolo.module accepts a function as an argument. The last argument to that function must be the next function: modules are loaded serially, so each module must call the next function or return a promise in order to continue the launch process. Other arguments to the function are object which you wish to inject into the module (these objects must be injected earlier).

By default, each module can inject:

  • env - environment object,
  • inject - injector - to add objects to the injector,

Module example:

import {App} from '@appolo/engine';
import {Injector} from '@appolo/inject';
export = async function(app:App){
    await app.module(async function(env:any,inject:Injector){
        let myModuleObject = {data:'test'};
        await toSomeThing();
        inject.addObject('myModuleObject',myModuleObject);
    });
}

Now we can inject myModuleObject to any class:

import {define,singleton,initMethod,inject} from '@appolo/inject';
@define()
export  class AuthMiddleware{
    @inject('myModuleObject') testObject:any
    public doSomeThing() {
        return this.testObject.data; //return 'test'
    }
}

Logger module example

A logger module example with winston

loggerModule.js file:

import winston = require('winston');
import {App} from '@appolo/engine';
import {Injector} from '@appolo/inject';
export = async function(app:App){
    await appolo.module(async function(env:any,inject:Injector){
        transports = [];
        transports.push(new (winston.transports.Console)({
            json: false,
            timestamp: true
        })
    });
    let logger = new (winston.Logger)({  transports: transports});
    inject.addObject('logger', logger);});

Now we you inject logger anywhere we need it:

import {define,singleton,initMethod,inject} from '@appolo/engine';
@define()
export class DataManager{
    @inject() logger:Logger
    public initialize(){
        this.logger.info("dataManager initialized",{someData:'someData'})
    }
}

Bootstrap

Once it launched, appolo will try to find an appolo bootstrap class and call it's run method. Only when the bootstrap is finished, the server will start

import {bootstrap,IBootstrap} from '@appolo/engine';
import {define,singleton,injectParam,initMethod,inject} from '@appolo/inject';
@define()
@bootstrap()
export class Bootstrap implements IBootstrap{
    @inject() someManager1:SomeManager1
    public async run(){
        //start your application logic here
        await this.someManager1.doSomeThing();
    }
}

Reset

You can reset appolo sever by calling appolo.reset(). This will clean all environments, config, injector and close the server.

Tests

 grunt test

License

The appolo library is released under the MIT license. So feel free to modify and distribute it as you wish.

Keywords

FAQs

Package last updated on 16 May 2023

Did you know?

Socket

Socket for GitHub automatically highlights issues in each pull request and monitors the health of all your open source dependencies. Discover the contents of your packages and block harmful activity before you install or update your dependencies.

Install

Related posts

SocketSocket SOC 2 Logo

Product

  • Package Alerts
  • Integrations
  • Docs
  • Pricing
  • FAQ
  • Roadmap
  • Changelog

Packages

npm

Stay in touch

Get open source security insights delivered straight into your inbox.


  • Terms
  • Privacy
  • Security

Made with ⚡️ by Socket Inc