codyjdalton / litstack Goto Github PK

An argument could be made that this could be done with next methods... could possibly close this if that meets the need.

Main use case for this is so the consumer can do:

@LitService()
class StorageService {

    constructor() {
        // .. do this once
        this.connect();
    }

    update() {
        // .. do something many times here
    }

    private connect() {
        // .. do something once here
    }
}

Currently, injecting the above service would give you a new instance of StorageService each time the component is new'd up (once per component route).

Could consider doing something like:

@LitModule({
    providers: [
        StorageService
    ]
})
export class CoreServicesModule {

}

Notice we don't have to make a custom forRoot() method like in Angular

And then in app.module:

@LitModule({
    imports: [
        CoreServicesModule
    ]
})
export class AppModule {

}

Now when you inject it in a component, it will have only constructed once.

This will require some changes to the Injector.resolve method, as well as the compiler.

This is due to a test calling the bootstrap method, causing the welcome message to be printed in the console. We can mock this.

Describe the bug
Installing litstack v0.4.0 does not install the dist as it is ignored in npmignore

To Reproduce
Steps to reproduce the behavior:

1. Type npm install
2. Attempt to use the library

Using our injector, we can:

1. Define a litConfig property
2. Set litConfig equal to metadata config
3. Change paths to include config

Is your feature request related to a problem? Please describe.
In order to prevent DDOS/other attack vectors, it would be good to set a rate limit on the endpoint or module level

Describe the solution you'd like
What would be nice is if I could do something like the following:
For modules:

@LitModule({
    rateLimit: {
        windowMs: 15 * 60 * 1000, // 15 minutes
        max: 100 // limit each IP to 100 requests per windowMs
    },
    exports: [
       ...
    ],
    imports: [
        ...
    ]
})
export class AppModule {

}

For components, maybe something like:

@LitComponent({
    rateLimit: {
        windowMs: 15 * 60 * 1000, // 15 minutes
        max: 100 // limit each IP to 100 requests per windowMs
   }
})
export class AppComponent {
    @GetMapping({
        produces: AppConstants.MESSAGE_V1,
        rateLimit: {
              windowMs: 15 * 60 * 1000, // 15 minutes
              max: 100 // limit each IP to 100 requests per windowMs
        }
    })
    home(res: HttpResponse) {
        res.success({
            message: AppConstants.WELCOME_MESSAGE
        });
    }
}

Describe alternatives you've considered
Alternative would be to add a middleware to the application or endpoint handling the rate limiting

We want to publish to npm on merge to master. Re-implement token.

Basically "do all the things"... might close this and open individual issues if the scope keeps increasing.

The framework should allow for multiple requests types.

@RequestMapping({
    type: [ RequestMethods.GET, RequestMethods.DELETE ]
})

MongoDB? Postgres? Technology agnostic?

• Coveralls for coverage
• Travis.yml for build stability